annotate utils.c @ 3775:f4eb5cc927f9 libavformat

matroskadec: unset matroska->done when seeking just in case someone try to seek back after reaching the end of file
author aurel
date Mon, 25 Aug 2008 00:17:31 +0000
parents 93d4898d9b6e
children d4b086282604
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1 /*
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2 * various utility functions for use within FFmpeg
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
4 *
1358
0899bfe4105c Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 1351
diff changeset
5 * This file is part of FFmpeg.
0899bfe4105c Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 1351
diff changeset
6 *
0899bfe4105c Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 1351
diff changeset
7 * FFmpeg is free software; you can redistribute it and/or
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
8 * modify it under the terms of the GNU Lesser General Public
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
9 * License as published by the Free Software Foundation; either
1358
0899bfe4105c Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 1351
diff changeset
10 * version 2.1 of the License, or (at your option) any later version.
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
11 *
1358
0899bfe4105c Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 1351
diff changeset
12 * FFmpeg is distributed in the hope that it will be useful,
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
15 * Lesser General Public License for more details.
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
16 *
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
17 * You should have received a copy of the GNU Lesser General Public
1358
0899bfe4105c Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 1351
diff changeset
18 * License along with FFmpeg; if not, write to the Free Software
896
edbe5c3717f9 Update licensing information: The FSF changed postal address.
diego
parents: 887
diff changeset
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
20 */
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
21 #include "avformat.h"
3286
6f61c3b36632 Use full path for #includes from another directory.
diego
parents: 3278
diff changeset
22 #include "libavcodec/opt.h"
6f61c3b36632 Use full path for #includes from another directory.
diego
parents: 3278
diff changeset
23 #include "libavutil/avstring.h"
2243
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
24 #include "riff.h"
2266
c3d2ed2063a0 Move av_gettime() back to lavf/utils.c
ramiro
parents: 2253
diff changeset
25 #include <sys/time.h>
c3d2ed2063a0 Move av_gettime() back to lavf/utils.c
ramiro
parents: 2253
diff changeset
26 #include <time.h>
3714
3790cb6c893d strcasecmp() requires #include <strings.h>
aurel
parents: 3710
diff changeset
27 #include <strings.h>
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
28
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
29 #undef NDEBUG
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
30 #include <assert.h>
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
31
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
32 /**
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
33 * @file libavformat/utils.c
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
34 * various utility functions for use within FFmpeg
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
35 */
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
36
3701
5cf9918994ed Implement avformat_version().
stefano
parents: 3698
diff changeset
37 unsigned avformat_version(void)
5cf9918994ed Implement avformat_version().
stefano
parents: 3698
diff changeset
38 {
5cf9918994ed Implement avformat_version().
stefano
parents: 3698
diff changeset
39 return LIBAVFORMAT_VERSION_INT;
5cf9918994ed Implement avformat_version().
stefano
parents: 3698
diff changeset
40 }
5cf9918994ed Implement avformat_version().
stefano
parents: 3698
diff changeset
41
3703
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
42 /* fraction handling */
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
43
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
44 /**
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
45 * f = val + (num / den) + 0.5.
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
46 *
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
47 * 'num' is normalized so that it is such as 0 <= num < den.
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
48 *
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
49 * @param f fractional number
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
50 * @param val integer value
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
51 * @param num must be >= 0
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
52 * @param den must be >= 1
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
53 */
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
54 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
55 {
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
56 num += (den >> 1);
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
57 if (num >= den) {
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
58 val += num / den;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
59 num = num % den;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
60 }
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
61 f->val = val;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
62 f->num = num;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
63 f->den = den;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
64 }
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
65
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
66 /**
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
67 * Fractional addition to f: f = f + (incr / f->den).
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
68 *
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
69 * @param f fractional number
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
70 * @param incr increment, can be positive or negative
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
71 */
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
72 static void av_frac_add(AVFrac *f, int64_t incr)
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
73 {
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
74 int64_t num, den;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
75
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
76 num = f->num + incr;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
77 den = f->den;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
78 if (num < 0) {
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
79 f->val += num / den;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
80 num = num % den;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
81 if (num < 0) {
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
82 num += den;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
83 f->val--;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
84 }
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
85 } else if (num >= den) {
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
86 f->val += num / den;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
87 num = num % den;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
88 }
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
89 f->num = num;
ff3b10be0cc7 Cosmetics: move at the beginning of the file the av_frac_* functions, avoid
stefano
parents: 3701
diff changeset
90 }
1135
107f90e1551b cleanup patch from Diego Petten <flameeyes@gentoo.org>
lu_zero
parents: 1127
diff changeset
91
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
92 /** head of registered input format linked list */
512
8dfd00fb6a6d Minor Patch for shared libs on Mac OSX by (Bill May <wmay at cisco dot com>)
michael
parents: 511
diff changeset
93 AVInputFormat *first_iformat = NULL;
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
94 /** head of registered output format linked list */
512
8dfd00fb6a6d Minor Patch for shared libs on Mac OSX by (Bill May <wmay at cisco dot com>)
michael
parents: 511
diff changeset
95 AVOutputFormat *first_oformat = NULL;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
96
2812
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
97 AVInputFormat *av_iformat_next(AVInputFormat *f)
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
98 {
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
99 if(f) return f->next;
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
100 else return first_iformat;
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
101 }
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
102
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
103 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
104 {
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
105 if(f) return f->next;
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
106 else return first_oformat;
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
107 }
173b5cb7efde av_*_next() API for libavformat
michael
parents: 2785
diff changeset
108
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
109 void av_register_input_format(AVInputFormat *format)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
110 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
111 AVInputFormat **p;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
112 p = &first_iformat;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
113 while (*p != NULL) p = &(*p)->next;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
114 *p = format;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
115 format->next = NULL;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
116 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
117
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
118 void av_register_output_format(AVOutputFormat *format)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
119 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
120 AVOutputFormat **p;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
121 p = &first_oformat;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
122 while (*p != NULL) p = &(*p)->next;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
123 *p = format;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
124 format->next = NULL;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
125 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
126
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
127 int match_ext(const char *filename, const char *extensions)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
128 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
129 const char *ext, *p;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
130 char ext1[32], *q;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
131
453
a699cf5c703d NULL pointers ...
michael
parents: 437
diff changeset
132 if(!filename)
a699cf5c703d NULL pointers ...
michael
parents: 437
diff changeset
133 return 0;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
134
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
135 ext = strrchr(filename, '.');
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
136 if (ext) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
137 ext++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
138 p = extensions;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
139 for(;;) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
140 q = ext1;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
141 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
142 *q++ = *p++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
143 *q = '\0';
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
144 if (!strcasecmp(ext1, ext))
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
145 return 1;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
146 if (*p == '\0')
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
147 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
148 p++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
149 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
150 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
151 return 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
152 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
153
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
154 AVOutputFormat *guess_format(const char *short_name, const char *filename,
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
155 const char *mime_type)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
156 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
157 AVOutputFormat *fmt, *fmt_found;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
158 int score_max, score;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
159
20
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
160 /* specific test for image sequences */
1169
d18cc9a1fd02 allow individual selection of muxers and demuxers
mru
parents: 1167
diff changeset
161 #ifdef CONFIG_IMAGE2_MUXER
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
162 if (!short_name && filename &&
1291
185190bdc185 Clarified API for numbered sequences, patch by Michel Bardiaux % mbardiaux A mediaxim P be %
gpoirier
parents: 1285
diff changeset
163 av_filename_number_test(filename) &&
583
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
164 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
165 return guess_format("image2", NULL, NULL);
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
166 }
1169
d18cc9a1fd02 allow individual selection of muxers and demuxers
mru
parents: 1167
diff changeset
167 #endif
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
168 /* Find the proper file type. */
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
169 fmt_found = NULL;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
170 score_max = 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
171 fmt = first_oformat;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
172 while (fmt != NULL) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
173 score = 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
174 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
175 score += 100;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
176 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
177 score += 10;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
178 if (filename && fmt->extensions &&
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
179 match_ext(filename, fmt->extensions)) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
180 score += 5;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
181 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
182 if (score > score_max) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
183 score_max = score;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
184 fmt_found = fmt;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
185 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
186 fmt = fmt->next;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
187 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
188 return fmt_found;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
189 }
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
190
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
191 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
192 const char *mime_type)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
193 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
194 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
195
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
196 if (fmt) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
197 AVOutputFormat *stream_fmt;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
198 char stream_format_name[64];
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
199
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
200 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
201 stream_fmt = guess_format(stream_format_name, NULL, NULL);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
202
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
203 if (stream_fmt)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
204 fmt = stream_fmt;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
205 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
206
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
207 return fmt;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
208 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
209
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
210 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
583
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
211 const char *filename, const char *mime_type, enum CodecType type){
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
212 if(type == CODEC_TYPE_VIDEO){
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
213 enum CodecID codec_id= CODEC_ID_NONE;
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
214
1169
d18cc9a1fd02 allow individual selection of muxers and demuxers
mru
parents: 1167
diff changeset
215 #ifdef CONFIG_IMAGE2_MUXER
586
d31051b85c3d try to guess the codec for imag2pipe too
michael
parents: 583
diff changeset
216 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
583
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
217 codec_id= av_guess_image2_codec(filename);
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
218 }
1169
d18cc9a1fd02 allow individual selection of muxers and demuxers
mru
parents: 1167
diff changeset
219 #endif
583
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
220 if(codec_id == CODEC_ID_NONE)
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
221 codec_id= fmt->video_codec;
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
222 return codec_id;
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
223 }else if(type == CODEC_TYPE_AUDIO)
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
224 return fmt->audio_codec;
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
225 else
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
226 return CODEC_ID_NONE;
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
227 }
7793767ffe35 move p*m from image/lavf -> image2/lavc
michael
parents: 581
diff changeset
228
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
229 AVInputFormat *av_find_input_format(const char *short_name)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
230 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
231 AVInputFormat *fmt;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
232 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
233 if (!strcmp(fmt->name, short_name))
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
234 return fmt;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
235 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
236 return NULL;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
237 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
238
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
239 /* memory handling */
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
240
797
f5a231a9a2f1 support changing in bitstream global headers into extradata style and back
michael
parents: 786
diff changeset
241 void av_destruct_packet(AVPacket *pkt)
53
fb671d87824e zero copy packet handling for DV1394 by Max Krasnyansky
bellard
parents: 32
diff changeset
242 {
fb671d87824e zero copy packet handling for DV1394 by Max Krasnyansky
bellard
parents: 32
diff changeset
243 av_free(pkt->data);
fb671d87824e zero copy packet handling for DV1394 by Max Krasnyansky
bellard
parents: 32
diff changeset
244 pkt->data = NULL; pkt->size = 0;
fb671d87824e zero copy packet handling for DV1394 by Max Krasnyansky
bellard
parents: 32
diff changeset
245 }
fb671d87824e zero copy packet handling for DV1394 by Max Krasnyansky
bellard
parents: 32
diff changeset
246
2139
12a46571c0c9 Export av_init_packet
ramiro
parents: 2080
diff changeset
247 void av_init_packet(AVPacket *pkt)
12a46571c0c9 Export av_init_packet
ramiro
parents: 2080
diff changeset
248 {
12a46571c0c9 Export av_init_packet
ramiro
parents: 2080
diff changeset
249 pkt->pts = AV_NOPTS_VALUE;
12a46571c0c9 Export av_init_packet
ramiro
parents: 2080
diff changeset
250 pkt->dts = AV_NOPTS_VALUE;
12a46571c0c9 Export av_init_packet
ramiro
parents: 2080
diff changeset
251 pkt->pos = -1;
12a46571c0c9 Export av_init_packet
ramiro
parents: 2080
diff changeset
252 pkt->duration = 0;
12a46571c0c9 Export av_init_packet
ramiro
parents: 2080
diff changeset
253 pkt->flags = 0;
12a46571c0c9 Export av_init_packet
ramiro
parents: 2080
diff changeset
254 pkt->stream_index = 0;
12a46571c0c9 Export av_init_packet
ramiro
parents: 2080
diff changeset
255 pkt->destruct= av_destruct_packet_nofree;
12a46571c0c9 Export av_init_packet
ramiro
parents: 2080
diff changeset
256 }
12a46571c0c9 Export av_init_packet
ramiro
parents: 2080
diff changeset
257
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
258 int av_new_packet(AVPacket *pkt, int size)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
259 {
1435
3d757766c236 remove gcc warning about void * used in arithmetic
bcoudurier
parents: 1423
diff changeset
260 uint8_t *data;
639
0b52743104ac integer overflows, heap corruption
michael
parents: 633
diff changeset
261 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
2273
7eb456c4ed8a Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents: 2266
diff changeset
262 return AVERROR(ENOMEM);
639
0b52743104ac integer overflows, heap corruption
michael
parents: 633
diff changeset
263 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
53
fb671d87824e zero copy packet handling for DV1394 by Max Krasnyansky
bellard
parents: 32
diff changeset
264 if (!data)
2273
7eb456c4ed8a Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents: 2266
diff changeset
265 return AVERROR(ENOMEM);
53
fb671d87824e zero copy packet handling for DV1394 by Max Krasnyansky
bellard
parents: 32
diff changeset
266 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
267
53
fb671d87824e zero copy packet handling for DV1394 by Max Krasnyansky
bellard
parents: 32
diff changeset
268 av_init_packet(pkt);
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
269 pkt->data = data;
53
fb671d87824e zero copy packet handling for DV1394 by Max Krasnyansky
bellard
parents: 32
diff changeset
270 pkt->size = size;
fb671d87824e zero copy packet handling for DV1394 by Max Krasnyansky
bellard
parents: 32
diff changeset
271 pkt->destruct = av_destruct_packet;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
272 return 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
273 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
274
775
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
275 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
276 {
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
277 int ret= av_new_packet(pkt, size);
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
278
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
279 if(ret<0)
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
280 return ret;
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
281
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
282 pkt->pos= url_ftell(s);
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
283
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
284 ret= get_buffer(s, pkt->data, size);
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
285 if(ret<=0)
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
286 av_free_packet(pkt);
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
287 else
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
288 pkt->size= ret;
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
289
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
290 return ret;
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
291 }
c5077fdab490 AVPacket.pos
michael
parents: 772
diff changeset
292
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
293 int av_dup_packet(AVPacket *pkt)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
294 {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
295 if (pkt->destruct != av_destruct_packet) {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
296 uint8_t *data;
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
297 /* We duplicate the packet and don't forget to add the padding again. */
639
0b52743104ac integer overflows, heap corruption
michael
parents: 633
diff changeset
298 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
2273
7eb456c4ed8a Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents: 2266
diff changeset
299 return AVERROR(ENOMEM);
330
c393ab803bcd copy packet without omitting the padding
bellard
parents: 319
diff changeset
300 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
301 if (!data) {
2273
7eb456c4ed8a Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents: 2266
diff changeset
302 return AVERROR(ENOMEM);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
303 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
304 memcpy(data, pkt->data, pkt->size);
330
c393ab803bcd copy packet without omitting the padding
bellard
parents: 319
diff changeset
305 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
306 pkt->data = data;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
307 pkt->destruct = av_destruct_packet;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
308 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
309 return 0;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
310 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
311
1291
185190bdc185 Clarified API for numbered sequences, patch by Michel Bardiaux % mbardiaux A mediaxim P be %
gpoirier
parents: 1285
diff changeset
312 int av_filename_number_test(const char *filename)
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
313 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
314 char buf[1024];
1291
185190bdc185 Clarified API for numbered sequences, patch by Michel Bardiaux % mbardiaux A mediaxim P be %
gpoirier
parents: 1285
diff changeset
315 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
316 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
317
1956
a60ed230798e require at least a score of AVPROBE_SCORE_MAX/4 or reaching of PROBE_BUF_MAX
michael
parents: 1941
diff changeset
318 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
319 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
320 AVInputFormat *fmt1, *fmt;
1956
a60ed230798e require at least a score of AVPROBE_SCORE_MAX/4 or reaching of PROBE_BUF_MAX
michael
parents: 1941
diff changeset
321 int score;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
322
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
323 fmt = NULL;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
324 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
1674
a216ebdce1ff Demuxers with AVFMT_NOFILE will open a (possibly different) file themselves,
reimar
parents: 1627
diff changeset
325 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
326 continue;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
327 score = 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
328 if (fmt1->read_probe) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
329 score = fmt1->read_probe(pd);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
330 } else if (fmt1->extensions) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
331 if (match_ext(pd->filename, fmt1->extensions)) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
332 score = 50;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
333 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
334 }
1956
a60ed230798e require at least a score of AVPROBE_SCORE_MAX/4 or reaching of PROBE_BUF_MAX
michael
parents: 1941
diff changeset
335 if (score > *score_max) {
a60ed230798e require at least a score of AVPROBE_SCORE_MAX/4 or reaching of PROBE_BUF_MAX
michael
parents: 1941
diff changeset
336 *score_max = score;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
337 fmt = fmt1;
3227
5b8e94932999 Do not detect a format if another has the same score.
michael
parents: 3209
diff changeset
338 }else if (score == *score_max)
5b8e94932999 Do not detect a format if another has the same score.
michael
parents: 3209
diff changeset
339 fmt = NULL;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
340 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
341 return fmt;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
342 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
343
1956
a60ed230798e require at least a score of AVPROBE_SCORE_MAX/4 or reaching of PROBE_BUF_MAX
michael
parents: 1941
diff changeset
344 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
a60ed230798e require at least a score of AVPROBE_SCORE_MAX/4 or reaching of PROBE_BUF_MAX
michael
parents: 1941
diff changeset
345 int score=0;
a60ed230798e require at least a score of AVPROBE_SCORE_MAX/4 or reaching of PROBE_BUF_MAX
michael
parents: 1941
diff changeset
346 return av_probe_input_format2(pd, is_opened, &score);
a60ed230798e require at least a score of AVPROBE_SCORE_MAX/4 or reaching of PROBE_BUF_MAX
michael
parents: 1941
diff changeset
347 }
a60ed230798e require at least a score of AVPROBE_SCORE_MAX/4 or reaching of PROBE_BUF_MAX
michael
parents: 1941
diff changeset
348
3565
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
349 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
350 {
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
351 AVInputFormat *fmt;
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
352 fmt = av_probe_input_format2(pd, 1, &score);
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
353
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
354 if (fmt) {
3574
23d0cdbf3308 Use strcmp() instead of strncmp() in set_codec_from_probe_data().
michael
parents: 3573
diff changeset
355 if (!strcmp(fmt->name, "mp3"))
3565
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
356 st->codec->codec_id = CODEC_ID_MP3;
3574
23d0cdbf3308 Use strcmp() instead of strncmp() in set_codec_from_probe_data().
michael
parents: 3573
diff changeset
357 else if (!strcmp(fmt->name, "ac3"))
3565
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
358 st->codec->codec_id = CODEC_ID_AC3;
3571
fe242597b6e4 Add mpegvideo and H.264 to the codec probe.
michael
parents: 3569
diff changeset
359 else if (!strcmp(fmt->name, "mpegvideo"))
fe242597b6e4 Add mpegvideo and H.264 to the codec probe.
michael
parents: 3569
diff changeset
360 st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
fe242597b6e4 Add mpegvideo and H.264 to the codec probe.
michael
parents: 3569
diff changeset
361 else if (!strcmp(fmt->name, "h264"))
fe242597b6e4 Add mpegvideo and H.264 to the codec probe.
michael
parents: 3569
diff changeset
362 st->codec->codec_id = CODEC_ID_H264;
3565
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
363 }
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
364 return !!fmt;
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
365 }
b3e976d080cd Move set_codec_from_probe_data() up to where the other probe functions are.
michael
parents: 3564
diff changeset
366
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
367 /************************************************************/
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
368 /* input media file */
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
369
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
370 /**
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
371 * Open a media file from an IO stream. 'fmt' must be specified.
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
372 */
371
b0e50e10472c av_log() cleanup
michael
parents: 370
diff changeset
373 static const char* format_to_name(void* ptr)
370
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
374 {
371
b0e50e10472c av_log() cleanup
michael
parents: 370
diff changeset
375 AVFormatContext* fc = (AVFormatContext*) ptr;
370
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
376 if(fc->iformat) return fc->iformat->name;
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
377 else if(fc->oformat) return fc->oformat->name;
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
378 else return "NULL";
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
379 }
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
380
1314
62a205694fbe Make OFFSET() reuse offsetof
takis
parents: 1313
diff changeset
381 #define OFFSET(x) offsetof(AVFormatContext,x)
2164
3804e39efbfd misc spelling fixes
diego
parents: 2163
diff changeset
382 #define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
1278
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
383 //these names are too long to be readable
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
384 #define E AV_OPT_FLAG_ENCODING_PARAM
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
385 #define D AV_OPT_FLAG_DECODING_PARAM
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
386
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
387 static const AVOption options[]={
1309
59b0e373c549 Use and set sane AVOption defaults
gpoirier
parents: 1307
diff changeset
388 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
1319
d93c1458d7be Migrate the "muxrate" OptionDef option to become an AVOption.
takis
parents: 1314
diff changeset
389 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
1320
5cda22873c51 Migrate the "packetsize" OptionDef option to become an AVOption.
takis
parents: 1319
diff changeset
390 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
1423
4eac39e2c41f fflags can/will be used for muxing too
bcoudurier
parents: 1388
diff changeset
391 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
1294
12398b868e18 ignore index parameter to ignore the ODML index in avi
michael
parents: 1291
diff changeset
392 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
12398b868e18 ignore index parameter to ignore the ODML index in avi
michael
parents: 1291
diff changeset
393 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
1309
59b0e373c549 Use and set sane AVOption defaults
gpoirier
parents: 1307
diff changeset
394 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
1301
8b14b8103d9f enable setting the year and track number using AVOption
gpoirier
parents: 1300
diff changeset
395 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
1984
2163852713c5 Add some help for the analyzeduration option.
diego
parents: 1966
diff changeset
396 {"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
2828
ff463ed64256 Add FF_OPT_TYPE_BINARY and use it to add a cryptokey option
reimar
parents: 2827
diff changeset
397 {"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
3063
74a63dbf5509 Set indexmem to a saner default.
michael
parents: 3058
diff changeset
398 {"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
3128
b5e2ce291882 Introduce max_picture_buffer variable in AVFormatContext,
ramiro
parents: 3118
diff changeset
399 {"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), FF_OPT_TYPE_INT, 3041280, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
3445
4a1ecbbf5725 Make timestamp debugging work nicer.
michael
parents: 3429
diff changeset
400 {"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, E|D, "fdebug"},
4a1ecbbf5725 Make timestamp debugging work nicer.
michael
parents: 3429
diff changeset
401 {"ts", NULL, 0, FF_OPT_TYPE_CONST, FF_FDEBUG_TS, INT_MIN, INT_MAX, E|D, "fdebug"},
1278
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
402 {NULL},
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
403 };
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
404
1303
44c593741578 undefines a few temporary defines which were not undefined after their usage.
gpoirier
parents: 1301
diff changeset
405 #undef E
44c593741578 undefines a few temporary defines which were not undefined after their usage.
gpoirier
parents: 1301
diff changeset
406 #undef D
44c593741578 undefines a few temporary defines which were not undefined after their usage.
gpoirier
parents: 1301
diff changeset
407 #undef DEFAULT
44c593741578 undefines a few temporary defines which were not undefined after their usage.
gpoirier
parents: 1301
diff changeset
408
1278
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
409 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
410
1626
8a13bce78882 remove #if obsoleted after last major version bump
bcoudurier
parents: 1625
diff changeset
411 static void avformat_get_context_defaults(AVFormatContext *s)
8a13bce78882 remove #if obsoleted after last major version bump
bcoudurier
parents: 1625
diff changeset
412 {
1278
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
413 memset(s, 0, sizeof(AVFormatContext));
1279
a12e0b434174 added option probesize; at the moment only used by mpegts.c
nicodvb
parents: 1278
diff changeset
414
1307
59dbb78518d4 make AVOptions default value field work.
gpoirier
parents: 1303
diff changeset
415 s->av_class = &av_format_context_class;
59dbb78518d4 make AVOptions default value field work.
gpoirier
parents: 1303
diff changeset
416
59dbb78518d4 make AVOptions default value field work.
gpoirier
parents: 1303
diff changeset
417 av_opt_set_defaults(s);
1278
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
418 }
370
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
419
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
420 AVFormatContext *av_alloc_format_context(void)
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
421 {
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
422 AVFormatContext *ic;
1313
dcefff960aeb Remove a redundant memset from libavformat.
takis
parents: 1309
diff changeset
423 ic = av_malloc(sizeof(AVFormatContext));
370
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
424 if (!ic) return ic;
1278
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
425 avformat_get_context_defaults(ic);
371
b0e50e10472c av_log() cleanup
michael
parents: 370
diff changeset
426 ic->av_class = &av_format_context_class;
370
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
427 return ic;
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
428 }
845f9de2c883 av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 367
diff changeset
429
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
430 int av_open_input_stream(AVFormatContext **ic_ptr,
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
431 ByteIOContext *pb, const char *filename,
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
432 AVInputFormat *fmt, AVFormatParameters *ap)
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
433 {
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
434 int err;
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
435 AVFormatContext *ic;
1003
2d57ce58f576 simplify AVFormatParameters NULL checks
michael
parents: 979
diff changeset
436 AVFormatParameters default_ap;
2d57ce58f576 simplify AVFormatParameters NULL checks
michael
parents: 979
diff changeset
437
2d57ce58f576 simplify AVFormatParameters NULL checks
michael
parents: 979
diff changeset
438 if(!ap){
2d57ce58f576 simplify AVFormatParameters NULL checks
michael
parents: 979
diff changeset
439 ap=&default_ap;
2d57ce58f576 simplify AVFormatParameters NULL checks
michael
parents: 979
diff changeset
440 memset(ap, 0, sizeof(default_ap));
2d57ce58f576 simplify AVFormatParameters NULL checks
michael
parents: 979
diff changeset
441 }
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
442
1278
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
443 if(!ap->prealloced_context)
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
444 ic = av_alloc_format_context();
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
445 else
f40d75601106 initial support for AVOption in AVFormatContext
nicodvb
parents: 1252
diff changeset
446 ic = *ic_ptr;
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
447 if (!ic) {
2273
7eb456c4ed8a Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents: 2266
diff changeset
448 err = AVERROR(ENOMEM);
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
449 goto fail;
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
450 }
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
451 ic->iformat = fmt;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
452 ic->pb = pb;
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
453 ic->duration = AV_NOPTS_VALUE;
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
454 ic->start_time = AV_NOPTS_VALUE;
2189
da71207a7cf1 use new string functions
mru
parents: 2165
diff changeset
455 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
456
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
457 /* allocate private data */
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
458 if (fmt->priv_data_size > 0) {
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
459 ic->priv_data = av_mallocz(fmt->priv_data_size);
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
460 if (!ic->priv_data) {
2273
7eb456c4ed8a Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents: 2266
diff changeset
461 err = AVERROR(ENOMEM);
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
462 goto fail;
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
463 }
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
464 } else {
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
465 ic->priv_data = NULL;
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
466 }
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
467
3536
231f0db9672f Allow NULL for read_header in AVInputFormat. See discussion in "[PATCH] allow
rbultje
parents: 3525
diff changeset
468 if (ic->iformat->read_header) {
3537
f02643ff8be2 Reindent after r14059, see "[PATCH] allow empty params for
rbultje
parents: 3536
diff changeset
469 err = ic->iformat->read_header(ic, ap);
f02643ff8be2 Reindent after r14059, see "[PATCH] allow empty params for
rbultje
parents: 3536
diff changeset
470 if (err < 0)
f02643ff8be2 Reindent after r14059, see "[PATCH] allow empty params for
rbultje
parents: 3536
diff changeset
471 goto fail;
3536
231f0db9672f Allow NULL for read_header in AVInputFormat. See discussion in "[PATCH] allow
rbultje
parents: 3525
diff changeset
472 }
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
473
1478
5e1b279a26d2 nut simple seeking first try
michael
parents: 1444
diff changeset
474 if (pb && !ic->data_offset)
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
475 ic->data_offset = url_ftell(ic->pb);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
476
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
477 *ic_ptr = ic;
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
478 return 0;
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
479 fail:
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
480 if (ic) {
3486
f68fcc8b8e9e factorize read_header failure freeing code
bcoudurier
parents: 3485
diff changeset
481 int i;
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
482 av_freep(&ic->priv_data);
3486
f68fcc8b8e9e factorize read_header failure freeing code
bcoudurier
parents: 3485
diff changeset
483 for(i=0;i<ic->nb_streams;i++) {
f68fcc8b8e9e factorize read_header failure freeing code
bcoudurier
parents: 3485
diff changeset
484 AVStream *st = ic->streams[i];
f68fcc8b8e9e factorize read_header failure freeing code
bcoudurier
parents: 3485
diff changeset
485 if (st) {
f68fcc8b8e9e factorize read_header failure freeing code
bcoudurier
parents: 3485
diff changeset
486 av_free(st->priv_data);
f68fcc8b8e9e factorize read_header failure freeing code
bcoudurier
parents: 3485
diff changeset
487 av_free(st->codec->extradata);
f68fcc8b8e9e factorize read_header failure freeing code
bcoudurier
parents: 3485
diff changeset
488 }
f68fcc8b8e9e factorize read_header failure freeing code
bcoudurier
parents: 3485
diff changeset
489 av_free(st);
f68fcc8b8e9e factorize read_header failure freeing code
bcoudurier
parents: 3485
diff changeset
490 }
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
491 }
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
492 av_free(ic);
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
493 *ic_ptr = NULL;
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
494 return err;
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
495 }
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
496
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
497 /** size of probe buffer, for guessing file type from file contents */
922
7f20b3ce1100 dynamically increase probe buffer until format is detected
michael
parents: 915
diff changeset
498 #define PROBE_BUF_MIN 2048
1111
d4a6d2ddc318 fix probe of high bitrate mpeg2video
michael
parents: 1030
diff changeset
499 #define PROBE_BUF_MAX (1<<20)
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
500
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
501 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
502 AVInputFormat *fmt,
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
503 int buf_size,
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
504 AVFormatParameters *ap)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
505 {
2829
51790e849ad3 Simplify av_open_input_file
reimar
parents: 2828
diff changeset
506 int err, probe_size;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
507 AVProbeData probe_data, *pd = &probe_data;
2829
51790e849ad3 Simplify av_open_input_file
reimar
parents: 2828
diff changeset
508 ByteIOContext *pb = NULL;
51790e849ad3 Simplify av_open_input_file
reimar
parents: 2828
diff changeset
509
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
510 pd->filename = "";
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
511 if (filename)
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
512 pd->filename = filename;
922
7f20b3ce1100 dynamically increase probe buffer until format is detected
michael
parents: 915
diff changeset
513 pd->buf = NULL;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
514 pd->buf_size = 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
515
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
516 if (!fmt) {
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
517 /* guess format if no file can be opened */
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
518 fmt = av_probe_input_format(pd, 0);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
519 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
520
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
521 /* Do not open file if the format does not need it. XXX: specific
172
9a0ab557b159 fixed RTP/TCP client support
bellard
parents: 168
diff changeset
522 hack needed to handle RTSP/TCP */
2829
51790e849ad3 Simplify av_open_input_file
reimar
parents: 2828
diff changeset
523 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
20
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
524 /* if no file needed do not try to open one */
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
525 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
526 goto fail;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
527 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
528 if (buf_size > 0) {
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
529 url_setbufsize(pb, buf_size);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
530 }
922
7f20b3ce1100 dynamically increase probe buffer until format is detected
michael
parents: 915
diff changeset
531
7f20b3ce1100 dynamically increase probe buffer until format is detected
michael
parents: 915
diff changeset
532 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
1956
a60ed230798e require at least a score of AVPROBE_SCORE_MAX/4 or reaching of PROBE_BUF_MAX
michael
parents: 1941
diff changeset
533 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
534 /* read probe data */
2001
1a3c9056982a allocate 32 extra bytes at the end of the probe buffer and remove most probe buf_size checks
michael
parents: 1984
diff changeset
535 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
922
7f20b3ce1100 dynamically increase probe buffer until format is detected
michael
parents: 915
diff changeset
536 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
2417
70b45051aef6 fix probe buffer issue. patch by Wolfram Gloger {wmglo at dent.med.uni-muenchen.de}.
jbr
parents: 2401
diff changeset
537 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
1824
9e1fecae7f80 check for any seeking failure during probe
bcoudurier
parents: 1818
diff changeset
538 if (url_fseek(pb, 0, SEEK_SET) < 0) {
502
813b0119a98e ffserver fixes by (Koos Vriezen <koos.vriezen at xs4all dot nl>)
michael
parents: 497
diff changeset
539 url_fclose(pb);
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
540 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
2829
51790e849ad3 Simplify av_open_input_file
reimar
parents: 2828
diff changeset
541 pb = NULL;
2274
b21c2af60bc9 Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents: 2273
diff changeset
542 err = AVERROR(EIO);
502
813b0119a98e ffserver fixes by (Koos Vriezen <koos.vriezen at xs4all dot nl>)
michael
parents: 497
diff changeset
543 goto fail;
813b0119a98e ffserver fixes by (Koos Vriezen <koos.vriezen at xs4all dot nl>)
michael
parents: 497
diff changeset
544 }
813b0119a98e ffserver fixes by (Koos Vriezen <koos.vriezen at xs4all dot nl>)
michael
parents: 497
diff changeset
545 }
922
7f20b3ce1100 dynamically increase probe buffer until format is detected
michael
parents: 915
diff changeset
546 /* guess file format */
1956
a60ed230798e require at least a score of AVPROBE_SCORE_MAX/4 or reaching of PROBE_BUF_MAX
michael
parents: 1941
diff changeset
547 fmt = av_probe_input_format2(pd, 1, &score);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
548 }
922
7f20b3ce1100 dynamically increase probe buffer until format is detected
michael
parents: 915
diff changeset
549 av_freep(&pd->buf);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
550 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
551
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
552 /* if still no format found, error */
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
553 if (!fmt) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
554 err = AVERROR_NOFMT;
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
555 goto fail;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
556 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
557
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
558 /* check filename in case an image number is expected */
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
559 if (fmt->flags & AVFMT_NEEDNUMBER) {
1291
185190bdc185 Clarified API for numbered sequences, patch by Michel Bardiaux % mbardiaux A mediaxim P be %
gpoirier
parents: 1285
diff changeset
560 if (!av_filename_number_test(filename)) {
20
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
561 err = AVERROR_NUMEXPECTED;
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
562 goto fail;
20
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
563 }
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
564 }
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
565 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
566 if (err)
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
567 goto fail;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
568 return 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
569 fail:
922
7f20b3ce1100 dynamically increase probe buffer until format is detected
michael
parents: 915
diff changeset
570 av_freep(&pd->buf);
2829
51790e849ad3 Simplify av_open_input_file
reimar
parents: 2828
diff changeset
571 if (pb)
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
572 url_fclose(pb);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
573 *ic_ptr = NULL;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
574 return err;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
575
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
576 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
577
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
578 /*******************************************************/
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
579
3698
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
580 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
581 AVPacketList **plast_pktl){
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
582 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
3566
77a07b9dbe98 Move add_to_pktbuf() before av_read_packet(). My future work on codec identification
michael
parents: 3565
diff changeset
583 if (!pktl)
77a07b9dbe98 Move add_to_pktbuf() before av_read_packet(). My future work on codec identification
michael
parents: 3565
diff changeset
584 return NULL;
77a07b9dbe98 Move add_to_pktbuf() before av_read_packet(). My future work on codec identification
michael
parents: 3565
diff changeset
585
3698
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
586 if (*packet_buffer)
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
587 (*plast_pktl)->next = pktl;
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
588 else
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
589 *packet_buffer = pktl;
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
590
3566
77a07b9dbe98 Move add_to_pktbuf() before av_read_packet(). My future work on codec identification
michael
parents: 3565
diff changeset
591 /* add the packet in the buffered packet list */
77a07b9dbe98 Move add_to_pktbuf() before av_read_packet(). My future work on codec identification
michael
parents: 3565
diff changeset
592 *plast_pktl = pktl;
77a07b9dbe98 Move add_to_pktbuf() before av_read_packet(). My future work on codec identification
michael
parents: 3565
diff changeset
593 pktl->pkt= *pkt;
77a07b9dbe98 Move add_to_pktbuf() before av_read_packet(). My future work on codec identification
michael
parents: 3565
diff changeset
594 return &pktl->pkt;
77a07b9dbe98 Move add_to_pktbuf() before av_read_packet(). My future work on codec identification
michael
parents: 3565
diff changeset
595 }
77a07b9dbe98 Move add_to_pktbuf() before av_read_packet(). My future work on codec identification
michael
parents: 3565
diff changeset
596
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
597 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
598 {
2832
8ac5fe1c5549 Allow overriding codec_ids.
michael
parents: 2830
diff changeset
599 int ret;
8ac5fe1c5549 Allow overriding codec_ids.
michael
parents: 2830
diff changeset
600 AVStream *st;
3568
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
601
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
602 for(;;){
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
603 AVPacketList *pktl = s->raw_packet_buffer;
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
604
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
605 if (pktl) {
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
606 *pkt = pktl->pkt;
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
607 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
608 s->raw_packet_buffer = pktl->next;
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
609 av_free(pktl);
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
610 return 0;
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
611 }
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
612 }
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
613
3569
michael
parents: 3568
diff changeset
614 av_init_packet(pkt);
michael
parents: 3568
diff changeset
615 ret= s->iformat->read_packet(s, pkt);
michael
parents: 3568
diff changeset
616 if (ret < 0)
michael
parents: 3568
diff changeset
617 return ret;
michael
parents: 3568
diff changeset
618 st= s->streams[pkt->stream_index];
2832
8ac5fe1c5549 Allow overriding codec_ids.
michael
parents: 2830
diff changeset
619
3569
michael
parents: 3568
diff changeset
620 switch(st->codec->codec_type){
michael
parents: 3568
diff changeset
621 case CODEC_TYPE_VIDEO:
michael
parents: 3568
diff changeset
622 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
michael
parents: 3568
diff changeset
623 break;
michael
parents: 3568
diff changeset
624 case CODEC_TYPE_AUDIO:
michael
parents: 3568
diff changeset
625 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
michael
parents: 3568
diff changeset
626 break;
michael
parents: 3568
diff changeset
627 case CODEC_TYPE_SUBTITLE:
michael
parents: 3568
diff changeset
628 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
michael
parents: 3568
diff changeset
629 break;
michael
parents: 3568
diff changeset
630 }
2832
8ac5fe1c5549 Allow overriding codec_ids.
michael
parents: 2830
diff changeset
631
3582
813a493658ee Move the codec_id overriding at a slightly better place.
michael
parents: 3581
diff changeset
632 if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
813a493658ee Move the codec_id overriding at a slightly better place.
michael
parents: 3581
diff changeset
633 return ret;
813a493658ee Move the codec_id overriding at a slightly better place.
michael
parents: 3581
diff changeset
634
3698
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
635 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
3582
813a493658ee Move the codec_id overriding at a slightly better place.
michael
parents: 3581
diff changeset
636
3568
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
637 if(st->codec->codec_id == CODEC_ID_PROBE){
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
638 AVProbeData *pd = &st->probe_data;
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
639
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
640 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
641 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
642 pd->buf_size += pkt->size;
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
643 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
644
3572
3f345a61cef0 Only try to probe the codec when the available data has roughly doubled
michael
parents: 3571
diff changeset
645 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
3573
michael
parents: 3572
diff changeset
646 set_codec_from_probe_data(st, pd, 1);
michael
parents: 3572
diff changeset
647 if(st->codec->codec_id != CODEC_ID_PROBE){
michael
parents: 3572
diff changeset
648 pd->buf_size=0;
michael
parents: 3572
diff changeset
649 av_freep(&pd->buf);
michael
parents: 3572
diff changeset
650 }
3572
3f345a61cef0 Only try to probe the codec when the available data has roughly doubled
michael
parents: 3571
diff changeset
651 }
3568
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
652 }
c24546b44906 New codec probing system try #1.
michael
parents: 3566
diff changeset
653 }
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
654 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
655
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
656 /**********************************************************/
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
657
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
658 /**
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
659 * Get the number of samples of an audio frame. Return -1 on error.
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
660 */
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
661 static int get_audio_frame_size(AVCodecContext *enc, int size)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
662 {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
663 int frame_size;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
664
3501
efcdb01aa0bf We cannot calculate the duration of vorbis packets even if we do know the
michael
parents: 3499
diff changeset
665 if(enc->codec_id == CODEC_ID_VORBIS)
efcdb01aa0bf We cannot calculate the duration of vorbis packets even if we do know the
michael
parents: 3499
diff changeset
666 return -1;
efcdb01aa0bf We cannot calculate the duration of vorbis packets even if we do know the
michael
parents: 3499
diff changeset
667
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
668 if (enc->frame_size <= 1) {
1158
51d3928ab00d av_get_bits_per_sample and due simplifications
bcoudurier
parents: 1142
diff changeset
669 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
51d3928ab00d av_get_bits_per_sample and due simplifications
bcoudurier
parents: 1142
diff changeset
670
51d3928ab00d av_get_bits_per_sample and due simplifications
bcoudurier
parents: 1142
diff changeset
671 if (bits_per_sample) {
846
fd1c2109505e Support de-/encoding of 24 and 32 bit PCM (from and to internal 16 bit).
reimar
parents: 842
diff changeset
672 if (enc->channels == 0)
fd1c2109505e Support de-/encoding of 24 and 32 bit PCM (from and to internal 16 bit).
reimar
parents: 842
diff changeset
673 return -1;
1160
c10e0dbce7de set proper bits_per_sample value for ADPCM codecs
aurel
parents: 1158
diff changeset
674 frame_size = (size << 3) / (bits_per_sample * enc->channels);
1158
51d3928ab00d av_get_bits_per_sample and due simplifications
bcoudurier
parents: 1142
diff changeset
675 } else {
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
676 /* used for example by ADPCM codecs */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
677 if (enc->bit_rate == 0)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
678 return -1;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
679 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
680 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
681 } else {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
682 frame_size = enc->frame_size;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
683 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
684 return frame_size;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
685 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
686
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
687
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
688 /**
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
689 * Return the frame duration in seconds. Return 0 if not available.
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
690 */
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
691 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
692 AVCodecParserContext *pc, AVPacket *pkt)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
693 {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
694 int frame_size;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
695
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
696 *pnum = 0;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
697 *pden = 0;
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
698 switch(st->codec->codec_type) {
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
699 case CODEC_TYPE_VIDEO:
757
7177bd7f1f47 10l (overflows)
michael
parents: 750
diff changeset
700 if(st->time_base.num*1000LL > st->time_base.den){
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
701 *pnum = st->time_base.num;
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
702 *pden = st->time_base.den;
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
703 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
704 *pnum = st->codec->time_base.num;
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
705 *pden = st->codec->time_base.den;
747
95c9cef3c3db prefer container time_base for frame duration guess
michael
parents: 743
diff changeset
706 if (pc && pc->repeat_pict) {
95c9cef3c3db prefer container time_base for frame duration guess
michael
parents: 743
diff changeset
707 *pden *= 2;
95c9cef3c3db prefer container time_base for frame duration guess
michael
parents: 743
diff changeset
708 *pnum = (*pnum) * (2 + pc->repeat_pict);
95c9cef3c3db prefer container time_base for frame duration guess
michael
parents: 743
diff changeset
709 }
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
710 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
711 break;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
712 case CODEC_TYPE_AUDIO:
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
713 frame_size = get_audio_frame_size(st->codec, pkt->size);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
714 if (frame_size < 0)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
715 break;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
716 *pnum = frame_size;
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
717 *pden = st->codec->sample_rate;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
718 break;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
719 default:
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
720 break;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
721 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
722 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
723
570
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
724 static int is_intra_only(AVCodecContext *enc){
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
725 if(enc->codec_type == CODEC_TYPE_AUDIO){
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
726 return 1;
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
727 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
728 switch(enc->codec_id){
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
729 case CODEC_ID_MJPEG:
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
730 case CODEC_ID_MJPEGB:
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
731 case CODEC_ID_LJPEG:
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
732 case CODEC_ID_RAWVIDEO:
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
733 case CODEC_ID_DVVIDEO:
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
734 case CODEC_ID_HUFFYUV:
599
0209f7365ccc split ffhuffyuv into 2 codecs:
lorenm
parents: 597
diff changeset
735 case CODEC_ID_FFVHUFF:
570
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
736 case CODEC_ID_ASV1:
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
737 case CODEC_ID_ASV2:
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
738 case CODEC_ID_VCR1:
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
739 return 1;
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
740 default: break;
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
741 }
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
742 }
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
743 return 0;
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
744 }
d82ccc7cff1c set keyframe flag at a more central place instead of in every demuxer for containers which only store intra only streams
michael
parents: 563
diff changeset
745
2421
b08793768c30 If a stream has no start time, but the first packet has a 'pts', use that
benoit
parents: 2417
diff changeset
746 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
b08793768c30 If a stream has no start time, but the first packet has a 'pts', use that
benoit
parents: 2417
diff changeset
747 int64_t dts, int64_t pts)
b08793768c30 If a stream has no start time, but the first packet has a 'pts', use that
benoit
parents: 2417
diff changeset
748 {
2300
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
749 AVStream *st= s->streams[stream_index];
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
750 AVPacketList *pktl= s->packet_buffer;
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
751
3554
e1e79e91af96 10000l for myself, my last change was incomplete.
michael
parents: 3552
diff changeset
752 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
2300
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
753 return;
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
754
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
755 st->first_dts= dts - st->cur_dts;
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
756 st->cur_dts= dts;
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
757
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
758 for(; pktl; pktl= pktl->next){
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
759 if(pktl->pkt.stream_index != stream_index)
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
760 continue;
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
761 //FIXME think more about this check
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
762 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
763 pktl->pkt.pts += st->first_dts;
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
764
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
765 if(pktl->pkt.dts != AV_NOPTS_VALUE)
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
766 pktl->pkt.dts += st->first_dts;
2301
45a6610e6a4f set a more reasonable start_time if the first timestamps are AV_NOPTS_VALUE
michael
parents: 2300
diff changeset
767
45a6610e6a4f set a more reasonable start_time if the first timestamps are AV_NOPTS_VALUE
michael
parents: 2300
diff changeset
768 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
45a6610e6a4f set a more reasonable start_time if the first timestamps are AV_NOPTS_VALUE
michael
parents: 2300
diff changeset
769 st->start_time= pktl->pkt.pts;
2300
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
770 }
2421
b08793768c30 If a stream has no start time, but the first packet has a 'pts', use that
benoit
parents: 2417
diff changeset
771 if (st->start_time == AV_NOPTS_VALUE)
b08793768c30 If a stream has no start time, but the first packet has a 'pts', use that
benoit
parents: 2417
diff changeset
772 st->start_time = pts;
2300
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
773 }
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
774
3048
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
775 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
776 {
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
777 AVPacketList *pktl= s->packet_buffer;
3418
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
778 int64_t cur_dts= 0;
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
779
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
780 if(st->first_dts != AV_NOPTS_VALUE){
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
781 cur_dts= st->first_dts;
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
782 for(; pktl; pktl= pktl->next){
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
783 if(pktl->pkt.stream_index == pkt->stream_index){
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
784 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
785 break;
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
786 cur_dts -= pkt->duration;
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
787 }
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
788 }
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
789 pktl= s->packet_buffer;
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
790 st->first_dts = cur_dts;
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
791 }else if(st->cur_dts)
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
792 return;
3048
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
793
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
794 for(; pktl; pktl= pktl->next){
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
795 if(pktl->pkt.stream_index != pkt->stream_index)
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
796 continue;
3056
4ce8908f4593 Get rid of a fake timestamp discontinuity at the begin of V.VOB.
michael
parents: 3055
diff changeset
797 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
4ce8908f4593 Get rid of a fake timestamp discontinuity at the begin of V.VOB.
michael
parents: 3055
diff changeset
798 && !pktl->pkt.duration){
3418
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
799 pktl->pkt.dts= cur_dts;
3417
e38326ffbb5e Do not set pts in update_initial_durations() if stream has b frames.
michael
parents: 3412
diff changeset
800 if(!st->codec->has_b_frames)
3418
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
801 pktl->pkt.pts= cur_dts;
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
802 cur_dts += pkt->duration;
3048
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
803 pktl->pkt.duration= pkt->duration;
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
804 }else
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
805 break;
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
806 }
3418
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
807 if(st->first_dts == AV_NOPTS_VALUE)
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
808 st->cur_dts= cur_dts;
3048
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
809 }
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
810
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
811 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
812 AVCodecParserContext *pc, AVPacket *pkt)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
813 {
1927
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
814 int num, den, presentation_delayed, delay, i;
2020
d0d39f124c6b timestamps generation improvement when parsing avi
benoit
parents: 2018
diff changeset
815 int64_t offset;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
816
2295
09176aa7014c deal with the case where one of pts,dts has wrapped but the other has not
michael
parents: 2294
diff changeset
817 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
09176aa7014c deal with the case where one of pts,dts has wrapped but the other has not
michael
parents: 2294
diff changeset
818 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
09176aa7014c deal with the case where one of pts,dts has wrapped but the other has not
michael
parents: 2294
diff changeset
819 pkt->dts -= 1LL<<st->pts_wrap_bits;
09176aa7014c deal with the case where one of pts,dts has wrapped but the other has not
michael
parents: 2294
diff changeset
820 }
09176aa7014c deal with the case where one of pts,dts has wrapped but the other has not
michael
parents: 2294
diff changeset
821
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
822 if (pkt->duration == 0) {
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
823 compute_frame_duration(&num, &den, st, pc, pkt);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
824 if (den && num) {
464
09e46bfc859c cur_dts in native timebase
michael
parents: 463
diff changeset
825 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
3048
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
826
3418
1e1c7967ba6c Make update_initial_durations() also work if a dts occured before a
michael
parents: 3417
diff changeset
827 if(pkt->duration != 0 && s->packet_buffer)
3048
a100291d922c Fix timestamps and durations if the first packets have no durations nor timestamps,
michael
parents: 3002
diff changeset
828 update_initial_durations(s, st, pkt);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
829 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
830 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
831
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
832 /* correct timestamps with byte offset if demuxers only have timestamps
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
833 on packet boundaries */
2020
d0d39f124c6b timestamps generation improvement when parsing avi
benoit
parents: 2018
diff changeset
834 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
d0d39f124c6b timestamps generation improvement when parsing avi
benoit
parents: 2018
diff changeset
835 /* this will estimate bitrate based on this frame's duration and size */
d0d39f124c6b timestamps generation improvement when parsing avi
benoit
parents: 2018
diff changeset
836 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
d0d39f124c6b timestamps generation improvement when parsing avi
benoit
parents: 2018
diff changeset
837 if(pkt->pts != AV_NOPTS_VALUE)
d0d39f124c6b timestamps generation improvement when parsing avi
benoit
parents: 2018
diff changeset
838 pkt->pts += offset;
d0d39f124c6b timestamps generation improvement when parsing avi
benoit
parents: 2018
diff changeset
839 if(pkt->dts != AV_NOPTS_VALUE)
d0d39f124c6b timestamps generation improvement when parsing avi
benoit
parents: 2018
diff changeset
840 pkt->dts += offset;
d0d39f124c6b timestamps generation improvement when parsing avi
benoit
parents: 2018
diff changeset
841 }
d0d39f124c6b timestamps generation improvement when parsing avi
benoit
parents: 2018
diff changeset
842
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
843 /* do we have a video B-frame ? */
1922
59d394f558b8 add a delay variable to hold the timestamp buffer size
michael
parents: 1921
diff changeset
844 delay= st->codec->has_b_frames;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
845 presentation_delayed = 0;
1928
19be2f007347 fix indention
michael
parents: 1927
diff changeset
846 /* XXX: need has_b_frame, but cannot get it if the codec is
19be2f007347 fix indention
michael
parents: 1927
diff changeset
847 not initialized */
19be2f007347 fix indention
michael
parents: 1927
diff changeset
848 if (delay &&
19be2f007347 fix indention
michael
parents: 1927
diff changeset
849 pc && pc->pict_type != FF_B_TYPE)
19be2f007347 fix indention
michael
parents: 1927
diff changeset
850 presentation_delayed = 1;
2164
3804e39efbfd misc spelling fixes
diego
parents: 2163
diff changeset
851 /* This may be redundant, but it should not hurt. */
1928
19be2f007347 fix indention
michael
parents: 1927
diff changeset
852 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
19be2f007347 fix indention
michael
parents: 1927
diff changeset
853 presentation_delayed = 1;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
854
1443
404048ea11bc Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents: 1442
diff changeset
855 // av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
856 /* interpolate PTS and DTS if they are not present */
3376
7db242158d51 Do not use the pts/dts calculation code which needs a parser, when no parser
michael
parents: 3341
diff changeset
857 if(delay==0 || (delay==1 && pc)){
1928
19be2f007347 fix indention
michael
parents: 1927
diff changeset
858 if (presentation_delayed) {
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
859 /* DTS = decompression timestamp */
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
860 /* PTS = presentation timestamp */
1928
19be2f007347 fix indention
michael
parents: 1927
diff changeset
861 if (pkt->dts == AV_NOPTS_VALUE)
3058
33ecae58665a revert 12156
michael
parents: 3056
diff changeset
862 pkt->dts = st->last_IP_pts;
2421
b08793768c30 If a stream has no start time, but the first packet has a 'pts', use that
benoit
parents: 2417
diff changeset
863 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1928
19be2f007347 fix indention
michael
parents: 1927
diff changeset
864 if (pkt->dts == AV_NOPTS_VALUE)
19be2f007347 fix indention
michael
parents: 1927
diff changeset
865 pkt->dts = st->cur_dts;
1925
9012fcda4257 simplify
michael
parents: 1924
diff changeset
866
1928
19be2f007347 fix indention
michael
parents: 1927
diff changeset
867 /* this is tricky: the dts must be incremented by the duration
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
868 of the frame we are displaying, i.e. the last I- or P-frame */
3058
33ecae58665a revert 12156
michael
parents: 3056
diff changeset
869 if (st->last_IP_duration == 0)
33ecae58665a revert 12156
michael
parents: 3056
diff changeset
870 st->last_IP_duration = pkt->duration;
3554
e1e79e91af96 10000l for myself, my last change was incomplete.
michael
parents: 3552
diff changeset
871 if(pkt->dts != AV_NOPTS_VALUE)
3555
michael
parents: 3554
diff changeset
872 st->cur_dts = pkt->dts + st->last_IP_duration;
3058
33ecae58665a revert 12156
michael
parents: 3056
diff changeset
873 st->last_IP_duration = pkt->duration;
33ecae58665a revert 12156
michael
parents: 3056
diff changeset
874 st->last_IP_pts= pkt->pts;
1928
19be2f007347 fix indention
michael
parents: 1927
diff changeset
875 /* cannot compute PTS if not present (we can compute it only
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
876 by knowing the future */
1936
7222bddac3e2 revert r8428, the check was not that useless
michael
parents: 1935
diff changeset
877 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1928
19be2f007347 fix indention
michael
parents: 1927
diff changeset
878 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
19be2f007347 fix indention
michael
parents: 1927
diff changeset
879 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
19be2f007347 fix indention
michael
parents: 1927
diff changeset
880 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
19be2f007347 fix indention
michael
parents: 1927
diff changeset
881 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
19be2f007347 fix indention
michael
parents: 1927
diff changeset
882 pkt->pts += pkt->duration;
19be2f007347 fix indention
michael
parents: 1927
diff changeset
883 // av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
19be2f007347 fix indention
michael
parents: 1927
diff changeset
884 }
618
65787cd808e4 workaround some broken mpeg-ps timestamps
michael
parents: 617
diff changeset
885 }
1928
19be2f007347 fix indention
michael
parents: 1927
diff changeset
886
19be2f007347 fix indention
michael
parents: 1927
diff changeset
887 /* presentation is not delayed : PTS and DTS are the same */
19be2f007347 fix indention
michael
parents: 1927
diff changeset
888 if(pkt->pts == AV_NOPTS_VALUE)
19be2f007347 fix indention
michael
parents: 1927
diff changeset
889 pkt->pts = pkt->dts;
2421
b08793768c30 If a stream has no start time, but the first packet has a 'pts', use that
benoit
parents: 2417
diff changeset
890 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1928
19be2f007347 fix indention
michael
parents: 1927
diff changeset
891 if(pkt->pts == AV_NOPTS_VALUE)
19be2f007347 fix indention
michael
parents: 1927
diff changeset
892 pkt->pts = st->cur_dts;
19be2f007347 fix indention
michael
parents: 1927
diff changeset
893 pkt->dts = pkt->pts;
3554
e1e79e91af96 10000l for myself, my last change was incomplete.
michael
parents: 3552
diff changeset
894 if(pkt->pts != AV_NOPTS_VALUE)
3555
michael
parents: 3554
diff changeset
895 st->cur_dts = pkt->pts + pkt->duration;
618
65787cd808e4 workaround some broken mpeg-ps timestamps
michael
parents: 617
diff changeset
896 }
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
897 }
1927
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
898
3710
48a262da0100 Prevent dts generation code to be executed when delay is > MAX_REORDER_DELAY,
bcoudurier
parents: 3703
diff changeset
899 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1927
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
900 st->pts_buffer[0]= pkt->pts;
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
901 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
902 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
903 if(pkt->dts == AV_NOPTS_VALUE)
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
904 pkt->dts= st->pts_buffer[0];
2300
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
905 if(delay>1){
2421
b08793768c30 If a stream has no start time, but the first packet has a 'pts', use that
benoit
parents: 2417
diff changeset
906 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
2300
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
907 }
1927
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
908 if(pkt->dts > st->cur_dts)
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
909 st->cur_dts = pkt->dts;
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
910 }
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
911
2949180856b0 reorder pts into dts support
michael
parents: 1926
diff changeset
912 // av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
913
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
914 /* update flags */
2666
1995444f6267 Move setting of key frame flag for intra-only codecs, ignoring key frame
heydowns
parents: 2658
diff changeset
915 if(is_intra_only(st->codec))
1995444f6267 Move setting of key frame flag for intra-only codecs, ignoring key frame
heydowns
parents: 2658
diff changeset
916 pkt->flags |= PKT_FLAG_KEY;
1995444f6267 Move setting of key frame flag for intra-only codecs, ignoring key frame
heydowns
parents: 2658
diff changeset
917 else if (pc) {
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
918 pkt->flags = 0;
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
919 /* keyframe computation */
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
920 if (pc->pict_type == FF_I_TYPE)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
921 pkt->flags |= PKT_FLAG_KEY;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
922 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
923 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
924
535
8430e4610971 uninitalized variables
michael
parents: 512
diff changeset
925 void av_destruct_packet_nofree(AVPacket *pkt)
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
926 {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
927 pkt->data = NULL; pkt->size = 0;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
928 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
929
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
930 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
931 {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
932 AVStream *st;
333
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
933 int len, ret, i;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
934
2032
af6110a58658 init packet before calling the demuxer
michael
parents: 2025
diff changeset
935 av_init_packet(pkt);
af6110a58658 init packet before calling the demuxer
michael
parents: 2025
diff changeset
936
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
937 for(;;) {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
938 /* select current input stream component */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
939 st = s->cur_st;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
940 if (st) {
797
f5a231a9a2f1 support changing in bitstream global headers into extradata style and back
michael
parents: 786
diff changeset
941 if (!st->need_parsing || !st->parser) {
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
942 /* no parsing needed: we just output the packet as is */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
943 /* raw data support */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
944 *pkt = s->cur_pkt;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
945 compute_pkt_fields(s, st, NULL, pkt);
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
946 s->cur_st = NULL;
1244
1a14fff172ca timestamp debugging av_logs()
michael
parents: 1185
diff changeset
947 break;
708
d79164865a7c more fine grained discarding of packets
michael
parents: 698
diff changeset
948 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
949 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
334
7f089db11f9a fixed incorrect PTS/DTS logic in MPEG video case (caused rare PTS glitches if start codes were between two PES packets)
bellard
parents: 333
diff changeset
950 s->cur_ptr, s->cur_len,
7f089db11f9a fixed incorrect PTS/DTS logic in MPEG video case (caused rare PTS glitches if start codes were between two PES packets)
bellard
parents: 333
diff changeset
951 s->cur_pkt.pts, s->cur_pkt.dts);
7f089db11f9a fixed incorrect PTS/DTS logic in MPEG video case (caused rare PTS glitches if start codes were between two PES packets)
bellard
parents: 333
diff changeset
952 s->cur_pkt.pts = AV_NOPTS_VALUE;
7f089db11f9a fixed incorrect PTS/DTS logic in MPEG video case (caused rare PTS glitches if start codes were between two PES packets)
bellard
parents: 333
diff changeset
953 s->cur_pkt.dts = AV_NOPTS_VALUE;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
954 /* increment read pointer */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
955 s->cur_ptr += len;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
956 s->cur_len -= len;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
957
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
958 /* return packet if any */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
959 if (pkt->size) {
333
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
960 got_packet:
2067
669e0f355f0c give the position offset of the file in the packet
benoit
parents: 2066
diff changeset
961 pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
962 pkt->duration = 0;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
963 pkt->stream_index = st->index;
334
7f089db11f9a fixed incorrect PTS/DTS logic in MPEG video case (caused rare PTS glitches if start codes were between two PES packets)
bellard
parents: 333
diff changeset
964 pkt->pts = st->parser->pts;
7f089db11f9a fixed incorrect PTS/DTS logic in MPEG video case (caused rare PTS glitches if start codes were between two PES packets)
bellard
parents: 333
diff changeset
965 pkt->dts = st->parser->dts;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
966 pkt->destruct = av_destruct_packet_nofree;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
967 compute_pkt_fields(s, st, st->parser, pkt);
1756
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
968
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
969 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
2932
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
970 ff_reduce_index(s, st->index);
1756
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
971 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
972 0, 0, AVINDEX_KEYFRAME);
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
973 }
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
974
1244
1a14fff172ca timestamp debugging av_logs()
michael
parents: 1185
diff changeset
975 break;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
976 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
977 } else {
319
6285d395baf4 fixed memory leak
bellard
parents: 303
diff changeset
978 /* free packet */
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
979 av_free_packet(&s->cur_pkt);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
980 s->cur_st = NULL;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
981 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
982 } else {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
983 /* read next packet */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
984 ret = av_read_packet(s, &s->cur_pkt);
333
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
985 if (ret < 0) {
1787
eb16c64144ee This fixes error handling for BeOS, removing the need for some ifdefs.
mmu_man
parents: 1756
diff changeset
986 if (ret == AVERROR(EAGAIN))
333
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
987 return ret;
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
988 /* return the last frames, if any */
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
989 for(i = 0; i < s->nb_streams; i++) {
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
990 st = s->streams[i];
797
f5a231a9a2f1 support changing in bitstream global headers into extradata style and back
michael
parents: 786
diff changeset
991 if (st->parser && st->need_parsing) {
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
992 av_parser_parse(st->parser, st->codec,
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
993 &pkt->data, &pkt->size,
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
994 NULL, 0,
334
7f089db11f9a fixed incorrect PTS/DTS logic in MPEG video case (caused rare PTS glitches if start codes were between two PES packets)
bellard
parents: 333
diff changeset
995 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
333
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
996 if (pkt->size)
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
997 goto got_packet;
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
998 }
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
999 }
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
1000 /* no more packets: really terminate parsing */
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1001 return ret;
333
e3beadc2ed83 make av_read_frame() return buffered frames at EOF
bellard
parents: 330
diff changeset
1002 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1003
3332
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1004 if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1005 s->cur_pkt.dts != AV_NOPTS_VALUE &&
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1006 s->cur_pkt.pts < s->cur_pkt.dts){
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1007 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1008 s->cur_pkt.stream_index,
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1009 s->cur_pkt.pts,
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1010 s->cur_pkt.dts,
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1011 s->cur_pkt.size);
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1012 // av_free_packet(&s->cur_pkt);
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1013 // return -1;
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1014 }
74e2cfc79cda Warn user about invalid timestamps.
michael
parents: 3330
diff changeset
1015
462
b69898ffc92a move time_base (pts_num/pts_den) from AVFormatContext -> AVStream
michael
parents: 453
diff changeset
1016 st = s->streams[s->cur_pkt.stream_index];
3445
4a1ecbbf5725 Make timestamp debugging work nicer.
michael
parents: 3429
diff changeset
1017 if(s->debug & FF_FDEBUG_TS)
3509
0c989007b4f0 Also print flags with FF_FDEBUG_TS.
michael
parents: 3504
diff changeset
1018 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1244
1a14fff172ca timestamp debugging av_logs()
michael
parents: 1185
diff changeset
1019 s->cur_pkt.stream_index,
1a14fff172ca timestamp debugging av_logs()
michael
parents: 1185
diff changeset
1020 s->cur_pkt.pts,
1a14fff172ca timestamp debugging av_logs()
michael
parents: 1185
diff changeset
1021 s->cur_pkt.dts,
3509
0c989007b4f0 Also print flags with FF_FDEBUG_TS.
michael
parents: 3504
diff changeset
1022 s->cur_pkt.size,
0c989007b4f0 Also print flags with FF_FDEBUG_TS.
michael
parents: 3504
diff changeset
1023 s->cur_pkt.flags);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1024
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1025 s->cur_st = st;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1026 s->cur_ptr = s->cur_pkt.data;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1027 s->cur_len = s->cur_pkt.size;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1028 if (st->need_parsing && !st->parser) {
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
1029 st->parser = av_parser_init(st->codec->codec_id);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1030 if (!st->parser) {
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
1031 /* no parser available: just output the raw packets */
2023
a3e79d6e4e3c add an enum for need_parsing
aurel
parents: 2020
diff changeset
1032 st->need_parsing = AVSTREAM_PARSE_NONE;
a3e79d6e4e3c add an enum for need_parsing
aurel
parents: 2020
diff changeset
1033 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
842
43210d766412 parse pict_type for streams in avi
michael
parents: 841
diff changeset
1034 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1035 }
1756
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1036 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
3411
d31673961099 rename last_frame_offset to next_frame_offset, due to r13615
bcoudurier
parents: 3378
diff changeset
1037 st->parser->next_frame_offset=
1756
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1038 st->parser->cur_offset= s->cur_pkt.pos;
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1039 }
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1040 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1041 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1042 }
3445
4a1ecbbf5725 Make timestamp debugging work nicer.
michael
parents: 3429
diff changeset
1043 if(s->debug & FF_FDEBUG_TS)
3509
0c989007b4f0 Also print flags with FF_FDEBUG_TS.
michael
parents: 3504
diff changeset
1044 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1244
1a14fff172ca timestamp debugging av_logs()
michael
parents: 1185
diff changeset
1045 pkt->stream_index,
1a14fff172ca timestamp debugging av_logs()
michael
parents: 1185
diff changeset
1046 pkt->pts,
1a14fff172ca timestamp debugging av_logs()
michael
parents: 1185
diff changeset
1047 pkt->dts,
3509
0c989007b4f0 Also print flags with FF_FDEBUG_TS.
michael
parents: 3504
diff changeset
1048 pkt->size,
0c989007b4f0 Also print flags with FF_FDEBUG_TS.
michael
parents: 3504
diff changeset
1049 pkt->flags);
1244
1a14fff172ca timestamp debugging av_logs()
michael
parents: 1185
diff changeset
1050
1a14fff172ca timestamp debugging av_logs()
michael
parents: 1185
diff changeset
1051 return 0;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1052 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1053
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1054 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1055 {
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1056 AVPacketList *pktl;
841
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1057 int eof=0;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1058 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1059
841
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1060 for(;;){
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1061 pktl = s->packet_buffer;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1062 if (pktl) {
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1063 AVPacket *next_pkt= &pktl->pkt;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1064
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1065 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1066 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1067 if( pktl->pkt.stream_index == next_pkt->stream_index
841
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1068 && next_pkt->dts < pktl->pkt.dts
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1069 && pktl->pkt.pts != pktl->pkt.dts //not b frame
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1070 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1071 next_pkt->pts= pktl->pkt.dts;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1072 }
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1073 pktl= pktl->next;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1074 }
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1075 pktl = s->packet_buffer;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1076 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1077
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1078 if( next_pkt->pts != AV_NOPTS_VALUE
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1079 || next_pkt->dts == AV_NOPTS_VALUE
841
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1080 || !genpts || eof){
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1081 /* read packet from packet buffer, if there is data */
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1082 *pkt = *next_pkt;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1083 s->packet_buffer = pktl->next;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1084 av_free(pktl);
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1085 return 0;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1086 }
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1087 }
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1088 if(genpts){
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1089 int ret= av_read_frame_internal(s, pkt);
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1090 if(ret<0){
1787
eb16c64144ee This fixes error handling for BeOS, removing the need for some ifdefs.
mmu_man
parents: 1756
diff changeset
1091 if(pktl && ret != AVERROR(EAGAIN)){
841
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1092 eof=1;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1093 continue;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1094 }else
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1095 return ret;
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1096 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1097
3698
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
1098 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
1099 &s->packet_buffer_end)) < 0)
2273
7eb456c4ed8a Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents: 2266
diff changeset
1100 return AVERROR(ENOMEM);
841
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1101 }else{
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1102 assert(!s->packet_buffer);
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1103 return av_read_frame_internal(s, pkt);
ba7631ba33a7 support fixing missing pts by parsing future frames
michael
parents: 840
diff changeset
1104 }
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1105 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1106 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1107
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1108 /* XXX: suppress the packet queue */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1109 static void flush_packet_queue(AVFormatContext *s)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1110 {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1111 AVPacketList *pktl;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1112
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1113 for(;;) {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1114 pktl = s->packet_buffer;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1115 if (!pktl)
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1116 break;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1117 s->packet_buffer = pktl->next;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1118 av_free_packet(&pktl->pkt);
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1119 av_free(pktl);
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1120 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1121 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1122
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1123 /*******************************************************/
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1124 /* seek support */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1125
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1126 int av_find_default_stream_index(AVFormatContext *s)
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1127 {
3423
613aff547655 Ensure the first audio stream is selected as the default stream
aurel
parents: 3418
diff changeset
1128 int first_audio_index = -1;
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1129 int i;
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1130 AVStream *st;
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1131
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1132 if (s->nb_streams <= 0)
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1133 return -1;
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1134 for(i = 0; i < s->nb_streams; i++) {
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1135 st = s->streams[i];
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
1136 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1137 return i;
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1138 }
3423
613aff547655 Ensure the first audio stream is selected as the default stream
aurel
parents: 3418
diff changeset
1139 if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
613aff547655 Ensure the first audio stream is selected as the default stream
aurel
parents: 3418
diff changeset
1140 first_audio_index = i;
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1141 }
3423
613aff547655 Ensure the first audio stream is selected as the default stream
aurel
parents: 3418
diff changeset
1142 return first_audio_index >= 0 ? first_audio_index : 0;
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1143 }
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1144
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
1145 /**
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
1146 * Flush the frame reader.
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
1147 */
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1148 static void av_read_frame_flush(AVFormatContext *s)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1149 {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1150 AVStream *st;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1151 int i;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1152
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1153 flush_packet_queue(s);
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1154
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1155 /* free previous packet */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1156 if (s->cur_st) {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1157 if (s->cur_st->parser)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1158 av_free_packet(&s->cur_pkt);
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1159 s->cur_st = NULL;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1160 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1161 /* fail safe */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1162 s->cur_ptr = NULL;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1163 s->cur_len = 0;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1164
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1165 /* for each stream, reset read state */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1166 for(i = 0; i < s->nb_streams; i++) {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1167 st = s->streams[i];
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1168
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1169 if (st->parser) {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1170 av_parser_close(st->parser);
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1171 st->parser = NULL;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1172 }
3058
33ecae58665a revert 12156
michael
parents: 3056
diff changeset
1173 st->last_IP_pts = AV_NOPTS_VALUE;
1935
d86a3bda9418 i think this is more correct
michael
parents: 1929
diff changeset
1174 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1175 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1176 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1177
1185
13dc486b272b Try to find out correct start time to make seeking faster and add some
reimar
parents: 1169
diff changeset
1178 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
560
63226381e03c generic cur_dts update
michael
parents: 557
diff changeset
1179 int i;
63226381e03c generic cur_dts update
michael
parents: 557
diff changeset
1180
63226381e03c generic cur_dts update
michael
parents: 557
diff changeset
1181 for(i = 0; i < s->nb_streams; i++) {
572
640706a29efb bug in libavformat av_update_cur_dts(), patch by (Nathan Kurz <nate at verse dot com>)
michael
parents: 570
diff changeset
1182 AVStream *st = s->streams[i];
560
63226381e03c generic cur_dts update
michael
parents: 557
diff changeset
1183
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1184 st->cur_dts = av_rescale(timestamp,
572
640706a29efb bug in libavformat av_update_cur_dts(), patch by (Nathan Kurz <nate at verse dot com>)
michael
parents: 570
diff changeset
1185 st->time_base.den * (int64_t)ref_st->time_base.num,
640706a29efb bug in libavformat av_update_cur_dts(), patch by (Nathan Kurz <nate at verse dot com>)
michael
parents: 570
diff changeset
1186 st->time_base.num * (int64_t)ref_st->time_base.den);
560
63226381e03c generic cur_dts update
michael
parents: 557
diff changeset
1187 }
63226381e03c generic cur_dts update
michael
parents: 557
diff changeset
1188 }
63226381e03c generic cur_dts update
michael
parents: 557
diff changeset
1189
2932
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1190 void ff_reduce_index(AVFormatContext *s, int stream_index)
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1191 {
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1192 AVStream *st= s->streams[stream_index];
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1193 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1194
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1195 if((unsigned)st->nb_index_entries >= max_entries){
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1196 int i;
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1197 for(i=0; 2*i<st->nb_index_entries; i++)
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1198 st->index_entries[i]= st->index_entries[2*i];
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1199 st->nb_index_entries= i;
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1200 }
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1201 }
f5de41d943e2 user specifyable maximum amount of memory to use for the index.
michael
parents: 2869
diff changeset
1202
354
6770ca07abe2 store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents: 346
diff changeset
1203 int av_add_index_entry(AVStream *st,
979
d2e5dfdf4def add size to AVIndex
michael
parents: 941
diff changeset
1204 int64_t pos, int64_t timestamp, int size, int distance, int flags)
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1205 {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1206 AVIndexEntry *entries, *ie;
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1207 int index;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1208
639
0b52743104ac integer overflows, heap corruption
michael
parents: 633
diff changeset
1209 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
0b52743104ac integer overflows, heap corruption
michael
parents: 633
diff changeset
1210 return -1;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1211
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1212 entries = av_fast_realloc(st->index_entries,
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1213 &st->index_entries_allocated_size,
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1214 (st->nb_index_entries + 1) *
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1215 sizeof(AVIndexEntry));
639
0b52743104ac integer overflows, heap corruption
michael
parents: 633
diff changeset
1216 if(!entries)
0b52743104ac integer overflows, heap corruption
michael
parents: 633
diff changeset
1217 return -1;
0b52743104ac integer overflows, heap corruption
michael
parents: 633
diff changeset
1218
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1219 st->index_entries= entries;
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1220
698
829c5c8e5cf2 keyframe & non keyframe index fixes
michael
parents: 686
diff changeset
1221 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1222
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1223 if(index<0){
354
6770ca07abe2 store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents: 346
diff changeset
1224 index= st->nb_index_entries++;
6770ca07abe2 store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents: 346
diff changeset
1225 ie= &entries[index];
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1226 assert(index==0 || ie[-1].timestamp < timestamp);
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1227 }else{
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1228 ie= &entries[index];
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1229 if(ie->timestamp != timestamp){
563
d141aa45ca86 fix assertion failure in case of timestamp discontinuities
michael
parents: 560
diff changeset
1230 if(ie->timestamp <= timestamp)
d141aa45ca86 fix assertion failure in case of timestamp discontinuities
michael
parents: 560
diff changeset
1231 return -1;
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1232 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1233 st->nb_index_entries++;
2164
3804e39efbfd misc spelling fixes
diego
parents: 2163
diff changeset
1234 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1235 distance= ie->min_distance;
354
6770ca07abe2 store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents: 346
diff changeset
1236 }
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1237
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1238 ie->pos = pos;
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1239 ie->timestamp = timestamp;
354
6770ca07abe2 store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents: 346
diff changeset
1240 ie->min_distance= distance;
979
d2e5dfdf4def add size to AVIndex
michael
parents: 941
diff changeset
1241 ie->size= size;
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1242 ie->flags = flags;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1243
354
6770ca07abe2 store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents: 346
diff changeset
1244 return index;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1245 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1246
597
d814669d2c13 int / int64 fix by (Wolfram Gloger <wmglo @@@ dent:med:uni-muenchen:de>)
michael
parents: 588
diff changeset
1247 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
698
829c5c8e5cf2 keyframe & non keyframe index fixes
michael
parents: 686
diff changeset
1248 int flags)
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1249 {
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1250 AVIndexEntry *entries= st->index_entries;
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1251 int nb_entries= st->nb_index_entries;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1252 int a, b, m;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1253 int64_t timestamp;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1254
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1255 a = - 1;
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1256 b = nb_entries;
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1257
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1258 while (b - a > 1) {
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1259 m = (a + b) >> 1;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1260 timestamp = entries[m].timestamp;
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1261 if(timestamp >= wanted_timestamp)
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1262 b = m;
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1263 if(timestamp <= wanted_timestamp)
346
e154eb1b7149 caching of timestamps for mpeg-ps so seeking is faster
michael
parents: 334
diff changeset
1264 a = m;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1265 }
698
829c5c8e5cf2 keyframe & non keyframe index fixes
michael
parents: 686
diff changeset
1266 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1267
698
829c5c8e5cf2 keyframe & non keyframe index fixes
michael
parents: 686
diff changeset
1268 if(!(flags & AVSEEK_FLAG_ANY)){
829c5c8e5cf2 keyframe & non keyframe index fixes
michael
parents: 686
diff changeset
1269 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
829c5c8e5cf2 keyframe & non keyframe index fixes
michael
parents: 686
diff changeset
1270 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
829c5c8e5cf2 keyframe & non keyframe index fixes
michael
parents: 686
diff changeset
1271 }
829c5c8e5cf2 keyframe & non keyframe index fixes
michael
parents: 686
diff changeset
1272 }
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1273
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1274 if(m == nb_entries)
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1275 return -1;
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1276 return m;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1277 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1278
2618
75b75b51ef2f Re-enable DEBUG_SEEK flag.
benoit
parents: 2605
diff changeset
1279 #define DEBUG_SEEK
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1280
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1281 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1282 AVInputFormat *avif= s->iformat;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1283 int64_t pos_min, pos_max, pos, pos_limit;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1284 int64_t ts_min, ts_max, ts;
1496
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1285 int index;
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1286 AVStream *st;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1287
463
696f41bc8784 store index for seeking in the native timebase of each stream
michael
parents: 462
diff changeset
1288 if (stream_index < 0)
696f41bc8784 store index for seeking in the native timebase of each stream
michael
parents: 462
diff changeset
1289 return -1;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1290
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1291 #ifdef DEBUG_SEEK
881
91dcb9da9be6 use PRIxN, %zd, %td formats where needed
mru
parents: 869
diff changeset
1292 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1293 #endif
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1294
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1295 ts_max=
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1296 ts_min= AV_NOPTS_VALUE;
2165
eac986610f47 misc typo fixes
diego
parents: 2164
diff changeset
1297 pos_limit= -1; //gcc falsely says it may be uninitialized
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1298
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1299 st= s->streams[stream_index];
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1300 if(st->index_entries){
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1301 AVIndexEntry *e;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1302
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
1303 index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1304 index= FFMAX(index, 0);
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1305 e= &st->index_entries[index];
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1306
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1307 if(e->timestamp <= target_ts || e->pos == e->min_distance){
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1308 pos_min= e->pos;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1309 ts_min= e->timestamp;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1310 #ifdef DEBUG_SEEK
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1311 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1312 pos_min,ts_min);
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1313 #endif
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1314 }else{
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1315 assert(index==0);
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1316 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1317
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1318 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
698
829c5c8e5cf2 keyframe & non keyframe index fixes
michael
parents: 686
diff changeset
1319 assert(index < st->nb_index_entries);
829c5c8e5cf2 keyframe & non keyframe index fixes
michael
parents: 686
diff changeset
1320 if(index >= 0){
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1321 e= &st->index_entries[index];
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1322 assert(e->timestamp >= target_ts);
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1323 pos_max= e->pos;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1324 ts_max= e->timestamp;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1325 pos_limit= pos_max - e->min_distance;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1326 #ifdef DEBUG_SEEK
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1327 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1328 pos_max,pos_limit, ts_max);
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1329 #endif
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1330 }
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1331 }
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1332
1496
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1333 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1334 if(pos<0)
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1335 return -1;
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1336
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1337 /* do the seek */
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
1338 url_fseek(s->pb, pos, SEEK_SET);
1496
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1339
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1340 av_update_cur_dts(s, st, ts);
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1341
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1342 return 0;
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1343 }
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1344
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1345 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1346 int64_t pos, ts;
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1347 int64_t start_pos, filesize;
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1348 int no_change;
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1349
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1350 #ifdef DEBUG_SEEK
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1351 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1352 #endif
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1353
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1354 if(ts_min == AV_NOPTS_VALUE){
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1355 pos_min = s->data_offset;
1496
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1356 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1357 if (ts_min == AV_NOPTS_VALUE)
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1358 return -1;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1359 }
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1360
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1361 if(ts_max == AV_NOPTS_VALUE){
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1362 int step= 1024;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
1363 filesize = url_fsize(s->pb);
810
2a84386ed2a8 avformat/av_seek_frame_binary with growing file patch by (Kenneth Aafly: kenneth, aafloy net)
michael
parents: 809
diff changeset
1364 pos_max = filesize - 1;
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1365 do{
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1366 pos_max -= step;
1496
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1367 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1368 step += step;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1369 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1370 if (ts_max == AV_NOPTS_VALUE)
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1371 return -1;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1372
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1373 for(;;){
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1374 int64_t tmp_pos= pos_max + 1;
1496
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1375 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1376 if(tmp_ts == AV_NOPTS_VALUE)
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1377 break;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1378 ts_max= tmp_ts;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1379 pos_max= tmp_pos;
810
2a84386ed2a8 avformat/av_seek_frame_binary with growing file patch by (Kenneth Aafly: kenneth, aafloy net)
michael
parents: 809
diff changeset
1380 if(tmp_pos >= filesize)
2a84386ed2a8 avformat/av_seek_frame_binary with growing file patch by (Kenneth Aafly: kenneth, aafloy net)
michael
parents: 809
diff changeset
1381 break;
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1382 }
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1383 pos_limit= pos_max;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1384 }
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1385
926
823fcde78b1b sanity checks for seeking
michael
parents: 922
diff changeset
1386 if(ts_min > ts_max){
823fcde78b1b sanity checks for seeking
michael
parents: 922
diff changeset
1387 return -1;
823fcde78b1b sanity checks for seeking
michael
parents: 922
diff changeset
1388 }else if(ts_min == ts_max){
823fcde78b1b sanity checks for seeking
michael
parents: 922
diff changeset
1389 pos_limit= pos_min;
823fcde78b1b sanity checks for seeking
michael
parents: 922
diff changeset
1390 }
823fcde78b1b sanity checks for seeking
michael
parents: 922
diff changeset
1391
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1392 no_change=0;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1393 while (pos_min < pos_limit) {
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1394 #ifdef DEBUG_SEEK
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1395 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1396 pos_min, pos_max,
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1397 ts_min, ts_max);
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1398 #endif
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1399 assert(pos_limit <= pos_max);
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1400
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1401 if(no_change==0){
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1402 int64_t approximate_keyframe_distance= pos_max - pos_limit;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1403 // interpolate position (better than dichotomy)
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1404 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1405 + pos_min - approximate_keyframe_distance;
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1406 }else if(no_change==1){
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1407 // bisection, if interpolation failed to change min or max pos last time
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1408 pos = (pos_min + pos_limit)>>1;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1409 }else{
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
1410 /* linear search if bisection failed, can only happen if there
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
1411 are very few or no keyframes between min/max */
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1412 pos=pos_min;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1413 }
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1414 if(pos <= pos_min)
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1415 pos= pos_min + 1;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1416 else if(pos > pos_limit)
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1417 pos= pos_limit;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1418 start_pos= pos;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1419
1496
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1420 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1421 if(pos == pos_max)
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1422 no_change++;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1423 else
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1424 no_change=0;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1425 #ifdef DEBUG_SEEK
881
91dcb9da9be6 use PRIxN, %zd, %td formats where needed
mru
parents: 869
diff changeset
1426 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1427 #endif
2034
355147fa5c72 dont assert(0) due to buggy rm demuxer
michael
parents: 2033
diff changeset
1428 if(ts == AV_NOPTS_VALUE){
355147fa5c72 dont assert(0) due to buggy rm demuxer
michael
parents: 2033
diff changeset
1429 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
355147fa5c72 dont assert(0) due to buggy rm demuxer
michael
parents: 2033
diff changeset
1430 return -1;
355147fa5c72 dont assert(0) due to buggy rm demuxer
michael
parents: 2033
diff changeset
1431 }
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1432 assert(ts != AV_NOPTS_VALUE);
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1433 if (target_ts <= ts) {
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1434 pos_limit = start_pos - 1;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1435 pos_max = pos;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1436 ts_max = ts;
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1437 }
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1438 if (target_ts >= ts) {
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1439 pos_min = pos;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1440 ts_min = ts;
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1441 }
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1442 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1443
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1444 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1445 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1446 #ifdef DEBUG_SEEK
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1447 pos_min = pos;
1496
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1448 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1449 pos_min++;
1496
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1450 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1451 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1452 pos, ts_min, target_ts, ts_max);
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1453 #endif
1496
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1454 *ts_ret= ts;
7e288adde245 split av_seek_frame_binary() so the code becomes idependant of AVInputFormat and AVIndex
michael
parents: 1478
diff changeset
1455 return pos;
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1456 }
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1457
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1458 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1459 int64_t pos_min, pos_max;
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1460 #if 0
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1461 AVStream *st;
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1462
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1463 if (stream_index < 0)
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1464 return -1;
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1465
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1466 st= s->streams[stream_index];
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1467 #endif
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1468
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1469 pos_min = s->data_offset;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
1470 pos_max = url_fsize(s->pb) - 1;
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1471
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1472 if (pos < pos_min) pos= pos_min;
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1473 else if(pos > pos_max) pos= pos_max;
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1474
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
1475 url_fseek(s->pb, pos, SEEK_SET);
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1476
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1477 #if 0
560
63226381e03c generic cur_dts update
michael
parents: 557
diff changeset
1478 av_update_cur_dts(s, st, ts);
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1479 #endif
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1480 return 0;
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1481 }
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1482
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1483 static int av_seek_frame_generic(AVFormatContext *s,
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1484 int stream_index, int64_t timestamp, int flags)
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1485 {
3612
c6186d4ceda0 check url_fseek return value, update seek reg tests
bcoudurier
parents: 3590
diff changeset
1486 int index, ret;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1487 AVStream *st;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1488 AVIndexEntry *ie;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1489
1756
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1490 st = s->streams[stream_index];
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1491
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1492 index = av_index_search_timestamp(st, timestamp, flags);
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1493
2033
1f882c0d0b79 fix av_seek_frame_generic() so that it doesnt fail if the
michael
parents: 2032
diff changeset
1494 if(index < 0 || index==st->nb_index_entries-1){
1756
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1495 int i;
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1496 AVPacket pkt;
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1497
3378
61f410022b10 redundant check--
michael
parents: 3376
diff changeset
1498 if(st->nb_index_entries){
61f410022b10 redundant check--
michael
parents: 3376
diff changeset
1499 assert(st->index_entries);
1756
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1500 ie= &st->index_entries[st->nb_index_entries-1];
3612
c6186d4ceda0 check url_fseek return value, update seek reg tests
bcoudurier
parents: 3590
diff changeset
1501 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
c6186d4ceda0 check url_fseek return value, update seek reg tests
bcoudurier
parents: 3590
diff changeset
1502 return ret;
1756
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1503 av_update_cur_dts(s, st, ie->timestamp);
3612
c6186d4ceda0 check url_fseek return value, update seek reg tests
bcoudurier
parents: 3590
diff changeset
1504 }else{
c6186d4ceda0 check url_fseek return value, update seek reg tests
bcoudurier
parents: 3590
diff changeset
1505 if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
c6186d4ceda0 check url_fseek return value, update seek reg tests
bcoudurier
parents: 3590
diff changeset
1506 return ret;
c6186d4ceda0 check url_fseek return value, update seek reg tests
bcoudurier
parents: 3590
diff changeset
1507 }
1756
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1508 for(i=0;; i++) {
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1509 int ret = av_read_frame(s, &pkt);
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1510 if(ret<0)
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1511 break;
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1512 av_free_packet(&pkt);
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1513 if(stream_index == pkt.stream_index){
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1514 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1515 break;
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1516 }
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1517 }
1756
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1518 index = av_index_search_timestamp(st, timestamp, flags);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1519 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1520 if (index < 0)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1521 return -1;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1522
1756
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1523 av_read_frame_flush(s);
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1524 if (s->iformat->read_seek){
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1525 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1526 return 0;
5d72afc6c8aa better generic index building and seeking code
michael
parents: 1755
diff changeset
1527 }
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1528 ie = &st->index_entries[index];
3612
c6186d4ceda0 check url_fseek return value, update seek reg tests
bcoudurier
parents: 3590
diff changeset
1529 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
c6186d4ceda0 check url_fseek return value, update seek reg tests
bcoudurier
parents: 3590
diff changeset
1530 return ret;
560
63226381e03c generic cur_dts update
michael
parents: 557
diff changeset
1531 av_update_cur_dts(s, st, ie->timestamp);
463
696f41bc8784 store index for seeking in the native timebase of each stream
michael
parents: 462
diff changeset
1532
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1533 return 0;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1534 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1535
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1536 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1537 {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1538 int ret;
463
696f41bc8784 store index for seeking in the native timebase of each stream
michael
parents: 462
diff changeset
1539 AVStream *st;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1540
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1541 av_read_frame_flush(s);
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1542
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1543 if(flags & AVSEEK_FLAG_BYTE)
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1544 return av_seek_frame_byte(s, stream_index, timestamp, flags);
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1545
463
696f41bc8784 store index for seeking in the native timebase of each stream
michael
parents: 462
diff changeset
1546 if(stream_index < 0){
696f41bc8784 store index for seeking in the native timebase of each stream
michael
parents: 462
diff changeset
1547 stream_index= av_find_default_stream_index(s);
696f41bc8784 store index for seeking in the native timebase of each stream
michael
parents: 462
diff changeset
1548 if(stream_index < 0)
696f41bc8784 store index for seeking in the native timebase of each stream
michael
parents: 462
diff changeset
1549 return -1;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1550
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1551 st= s->streams[stream_index];
557
084de726b4d0 default stream timebase docs patch by (Nathan Kurz <nate at verse dot com>)
michael
parents: 556
diff changeset
1552 /* timestamp for default must be expressed in AV_TIME_BASE units */
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1553 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
463
696f41bc8784 store index for seeking in the native timebase of each stream
michael
parents: 462
diff changeset
1554 }
696f41bc8784 store index for seeking in the native timebase of each stream
michael
parents: 462
diff changeset
1555 st= s->streams[stream_index];
696f41bc8784 store index for seeking in the native timebase of each stream
michael
parents: 462
diff changeset
1556
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1557 /* first, we try the format specific seek */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1558 if (s->iformat->read_seek)
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1559 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1560 else
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1561 ret = -1;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1562 if (ret >= 0) {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1563 return 0;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1564 }
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1565
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1566 if(s->iformat->read_timestamp)
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1567 return av_seek_frame_binary(s, stream_index, timestamp, flags);
437
50bae308f71e moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents: 425
diff changeset
1568 else
555
0a997108f384 use native timebase for seeking
michael
parents: 554
diff changeset
1569 return av_seek_frame_generic(s, stream_index, timestamp, flags);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1570 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1571
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
1572 /*******************************************************/
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1573
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
1574 /**
2523
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1575 * Returns TRUE if the stream has accurate duration in any stream.
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
1576 *
2523
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1577 * @return TRUE if the stream has accurate duration for at least one component.
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
1578 */
2523
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1579 static int av_has_duration(AVFormatContext *ic)
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1580 {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1581 int i;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1582 AVStream *st;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1583
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1584 for(i = 0;i < ic->nb_streams; i++) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1585 st = ic->streams[i];
2523
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1586 if (st->duration != AV_NOPTS_VALUE)
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1587 return 1;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1588 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1589 return 0;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1590 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1591
802
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
1592 /**
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
1593 * Estimate the stream timings from the one of each components.
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
1594 *
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
1595 * Also computes the global bitrate if possible.
ea0e995ac4a8 part of the 'libavformat/utils.c doxygen documentation' patch by (Daniel Kristjansson: danielk, cat nyu edu)
michael
parents: 801
diff changeset
1596 */
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1597 static void av_update_stream_timings(AVFormatContext *ic)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1598 {
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1599 int64_t start_time, start_time1, end_time, end_time1;
2523
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1600 int64_t duration, duration1;
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1601 int i;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1602 AVStream *st;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1603
1557
3879e6def12f use standard INT64_MAX instead of MAXINT64 (and MIN)
mru
parents: 1556
diff changeset
1604 start_time = INT64_MAX;
3879e6def12f use standard INT64_MAX instead of MAXINT64 (and MIN)
mru
parents: 1556
diff changeset
1605 end_time = INT64_MIN;
2523
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1606 duration = INT64_MIN;
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1607 for(i = 0;i < ic->nb_streams; i++) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1608 st = ic->streams[i];
2962
0cf3b8359da8 ensure av_rescale_q() can be calculated (won't divide by zero)
aurel
parents: 2936
diff changeset
1609 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1610 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1611 if (start_time1 < start_time)
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1612 start_time = start_time1;
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1613 if (st->duration != AV_NOPTS_VALUE) {
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1614 end_time1 = start_time1
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1615 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1616 if (end_time1 > end_time)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1617 end_time = end_time1;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1618 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1619 }
2523
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1620 if (st->duration != AV_NOPTS_VALUE) {
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1621 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1622 if (duration1 > duration)
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1623 duration = duration1;
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1624 }
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1625 }
1557
3879e6def12f use standard INT64_MAX instead of MAXINT64 (and MIN)
mru
parents: 1556
diff changeset
1626 if (start_time != INT64_MAX) {
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1627 ic->start_time = start_time;
1557
3879e6def12f use standard INT64_MAX instead of MAXINT64 (and MIN)
mru
parents: 1556
diff changeset
1628 if (end_time != INT64_MIN) {
2523
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1629 if (end_time - start_time > duration)
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1630 duration = end_time - start_time;
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1631 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1632 }
2523
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1633 if (duration != INT64_MIN) {
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1634 ic->duration = duration;
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1635 if (ic->file_size > 0) {
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
1636 /* compute the bitrate */
2523
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1637 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1638 (double)ic->duration;
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1639 }
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1640 }
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1641 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1642
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1643 static void fill_all_stream_timings(AVFormatContext *ic)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1644 {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1645 int i;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1646 AVStream *st;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1647
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1648 av_update_stream_timings(ic);
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1649 for(i = 0;i < ic->nb_streams; i++) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1650 st = ic->streams[i];
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1651 if (st->start_time == AV_NOPTS_VALUE) {
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1652 if(ic->start_time != AV_NOPTS_VALUE)
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1653 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1654 if(ic->duration != AV_NOPTS_VALUE)
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1655 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1656 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1657 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1658 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1659
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1660 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1661 {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1662 int64_t filesize, duration;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1663 int bit_rate, i;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1664 AVStream *st;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1665
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1666 /* if bit_rate is already set, we believe it */
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1667 if (ic->bit_rate == 0) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1668 bit_rate = 0;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1669 for(i=0;i<ic->nb_streams;i++) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1670 st = ic->streams[i];
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
1671 bit_rate += st->codec->bit_rate;
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1672 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1673 ic->bit_rate = bit_rate;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1674 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1675
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1676 /* if duration is already set, we believe it */
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1677 if (ic->duration == AV_NOPTS_VALUE &&
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1678 ic->bit_rate != 0 &&
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1679 ic->file_size != 0) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1680 filesize = ic->file_size;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1681 if (filesize > 0) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1682 for(i = 0; i < ic->nb_streams; i++) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1683 st = ic->streams[i];
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1684 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2401
c356a88cedf6 Do not butcher start_time in av_estimate_timings_from_bit_rate().
michael
parents: 2400
diff changeset
1685 if (st->duration == AV_NOPTS_VALUE)
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1686 st->duration = duration;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1687 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1688 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1689 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1690 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1691
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1692 #define DURATION_MAX_READ_SIZE 250000
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1693
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1694 /* only usable for MPEG-PS streams */
1755
41160bae24b5 Fix audio corruption when cutting.
takis
parents: 1751
diff changeset
1695 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1696 {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1697 AVPacket pkt1, *pkt = &pkt1;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1698 AVStream *st;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1699 int read_size, i, ret;
838
128838bc4bb6 kill a bunch of compiler warnings
mru
parents: 820
diff changeset
1700 int64_t end_time;
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1701 int64_t filesize, offset, duration;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1702
2043
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1703 /* free previous packet */
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1704 if (ic->cur_st && ic->cur_st->parser)
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1705 av_free_packet(&ic->cur_pkt);
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1706 ic->cur_st = NULL;
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1707
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1708 /* flush packet queue */
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1709 flush_packet_queue(ic);
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1710
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1711 for(i=0;i<ic->nb_streams;i++) {
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1712 st = ic->streams[i];
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1713 if (st->parser) {
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1714 av_parser_close(st->parser);
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1715 st->parser= NULL;
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1716 }
3446000701c4 Fix reading PTSs and DTSs in libavformat, by reverting r8465.
lucabe
parents: 2037
diff changeset
1717 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1718
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1719 /* we read the first packets to get the first PTS (not fully
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1720 accurate, but it is enough now) */
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
1721 url_fseek(ic->pb, 0, SEEK_SET);
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1722 read_size = 0;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1723 for(;;) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1724 if (read_size >= DURATION_MAX_READ_SIZE)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1725 break;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1726 /* if all info is available, we can stop */
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1727 for(i = 0;i < ic->nb_streams; i++) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1728 st = ic->streams[i];
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1729 if (st->start_time == AV_NOPTS_VALUE)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1730 break;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1731 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1732 if (i == ic->nb_streams)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1733 break;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1734
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1735 ret = av_read_packet(ic, pkt);
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1736 if (ret != 0)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1737 break;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1738 read_size += pkt->size;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1739 st = ic->streams[pkt->stream_index];
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1740 if (pkt->pts != AV_NOPTS_VALUE) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1741 if (st->start_time == AV_NOPTS_VALUE)
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1742 st->start_time = pkt->pts;
224
8d1569be0ee1 memory leak fix by (Tom Dexter <devel at www dot digitalaudiorock dot com>)
michaelni
parents: 205
diff changeset
1743 }
8d1569be0ee1 memory leak fix by (Tom Dexter <devel at www dot digitalaudiorock dot com>)
michaelni
parents: 205
diff changeset
1744 av_free_packet(pkt);
8d1569be0ee1 memory leak fix by (Tom Dexter <devel at www dot digitalaudiorock dot com>)
michaelni
parents: 205
diff changeset
1745 }
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1746
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1747 /* estimate the end time (duration) */
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1748 /* XXX: may need to support wrapping */
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1749 filesize = ic->file_size;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1750 offset = filesize - DURATION_MAX_READ_SIZE;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1751 if (offset < 0)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1752 offset = 0;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1753
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
1754 url_fseek(ic->pb, offset, SEEK_SET);
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1755 read_size = 0;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1756 for(;;) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1757 if (read_size >= DURATION_MAX_READ_SIZE)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1758 break;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1759
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1760 ret = av_read_packet(ic, pkt);
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1761 if (ret != 0)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1762 break;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1763 read_size += pkt->size;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1764 st = ic->streams[pkt->stream_index];
2399
e1fdab28da80 There is no guarantee that every stream will
michael
parents: 2398
diff changeset
1765 if (pkt->pts != AV_NOPTS_VALUE &&
e1fdab28da80 There is no guarantee that every stream will
michael
parents: 2398
diff changeset
1766 st->start_time != AV_NOPTS_VALUE) {
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1767 end_time = pkt->pts;
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1768 duration = end_time - st->start_time;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1769 if (duration > 0) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1770 if (st->duration == AV_NOPTS_VALUE ||
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1771 st->duration < duration)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1772 st->duration = duration;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1773 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1774 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1775 av_free_packet(pkt);
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1776 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1777
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
1778 fill_all_stream_timings(ic);
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1779
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
1780 url_fseek(ic->pb, old_offset, SEEK_SET);
2398
3306dae77205 fix cur_dts at the end of av_estimate_timings_from_pts()
michael
parents: 2320
diff changeset
1781 for(i=0; i<ic->nb_streams; i++){
3306dae77205 fix cur_dts at the end of av_estimate_timings_from_pts()
michael
parents: 2320
diff changeset
1782 st= ic->streams[i];
3306dae77205 fix cur_dts at the end of av_estimate_timings_from_pts()
michael
parents: 2320
diff changeset
1783 st->cur_dts= st->first_dts;
3058
33ecae58665a revert 12156
michael
parents: 3056
diff changeset
1784 st->last_IP_pts = AV_NOPTS_VALUE;
2398
3306dae77205 fix cur_dts at the end of av_estimate_timings_from_pts()
michael
parents: 2320
diff changeset
1785 }
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1786 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1787
1755
41160bae24b5 Fix audio corruption when cutting.
takis
parents: 1751
diff changeset
1788 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1789 {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1790 int64_t file_size;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1791
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1792 /* get the file size, if possible */
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1793 if (ic->iformat->flags & AVFMT_NOFILE) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1794 file_size = 0;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1795 } else {
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
1796 file_size = url_fsize(ic->pb);
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1797 if (file_size < 0)
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1798 file_size = 0;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1799 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1800 ic->file_size = file_size;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1801
1169
d18cc9a1fd02 allow individual selection of muxers and demuxers
mru
parents: 1167
diff changeset
1802 if ((!strcmp(ic->iformat->name, "mpeg") ||
d18cc9a1fd02 allow individual selection of muxers and demuxers
mru
parents: 1167
diff changeset
1803 !strcmp(ic->iformat->name, "mpegts")) &&
2841
a41a1ec2213c use proper url_is_streamed() API
aurel
parents: 2839
diff changeset
1804 file_size && !url_is_streamed(ic->pb)) {
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1805 /* get accurate estimate from the PTSes */
1755
41160bae24b5 Fix audio corruption when cutting.
takis
parents: 1751
diff changeset
1806 av_estimate_timings_from_pts(ic, old_offset);
2523
db7d46749b55 Make sure that if a stream has a duration but the container doesn't
benoit
parents: 2522
diff changeset
1807 } else if (av_has_duration(ic)) {
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
1808 /* at least one component has timings - we use them for all
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1809 the components */
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1810 fill_all_stream_timings(ic);
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1811 } else {
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
1812 /* less precise: use bitrate info */
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1813 av_estimate_timings_from_bit_rate(ic);
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1814 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1815 av_update_stream_timings(ic);
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1816
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1817 #if 0
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1818 {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1819 int i;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1820 AVStream *st;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1821 for(i = 0;i < ic->nb_streams; i++) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1822 st = ic->streams[i];
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1823 printf("%d: start_time: %0.3f duration: %0.3f\n",
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1824 i, (double)st->start_time / AV_TIME_BASE,
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1825 (double)st->duration / AV_TIME_BASE);
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1826 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1827 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1828 (double)ic->start_time / AV_TIME_BASE,
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1829 (double)ic->duration / AV_TIME_BASE,
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1830 ic->bit_rate / 1000);
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1831 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1832 #endif
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1833 }
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
1834
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1835 static int has_codec_parameters(AVCodecContext *enc)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1836 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1837 int val;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1838 switch(enc->codec_type) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1839 case CODEC_TYPE_AUDIO:
3412
17074236eb14 Audio channels and sample rate must be set in order to skip
andoma
parents: 3411
diff changeset
1840 val = enc->sample_rate && enc->channels;
3504
2bbc4f176591 make av_find_stream_info find frame_size for aac too
bcoudurier
parents: 3503
diff changeset
1841 if(!enc->frame_size &&
2bbc4f176591 make av_find_stream_info find frame_size for aac too
bcoudurier
parents: 3503
diff changeset
1842 (enc->codec_id == CODEC_ID_VORBIS ||
2bbc4f176591 make av_find_stream_info find frame_size for aac too
bcoudurier
parents: 3503
diff changeset
1843 enc->codec_id == CODEC_ID_AAC))
3503
c1c3fb1711b9 Make av_find_stream_info() find the frame_size for vorbis.
michael
parents: 3502
diff changeset
1844 return 0;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1845 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1846 case CODEC_TYPE_VIDEO:
737
119ac74d1c49 PIX_FMT_NONE and related fixes
michael
parents: 717
diff changeset
1847 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1848 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1849 default:
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1850 val = 1;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1851 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1852 }
3278
1de87c1b6a12 Remove unnecessary parentheses from return calls.
diego
parents: 3248
diff changeset
1853 return enc->codec_id != CODEC_ID_NONE && val != 0;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1854 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1855
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1856 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1857 {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1858 int16_t *samples;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1859 AVCodec *codec;
1818
0c28d35086f5 use avcodec_decode_audio2
bcoudurier
parents: 1804
diff changeset
1860 int got_picture, data_size, ret=0;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1861 AVFrame picture;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1862
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
1863 if(!st->codec->codec){
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
1864 codec = avcodec_find_decoder(st->codec->codec_id);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1865 if (!codec)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1866 return -1;
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
1867 ret = avcodec_open(st->codec, codec);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1868 if (ret < 0)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1869 return ret;
801
bca2334ff177 dont open and close codec at every call of try_decode_frame() as this is not only slow but also fails if the previous frame is needed for setting some parameters correctly
michael
parents: 797
diff changeset
1870 }
737
119ac74d1c49 PIX_FMT_NONE and related fixes
michael
parents: 717
diff changeset
1871
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
1872 if(!has_codec_parameters(st->codec)){
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
1873 switch(st->codec->codec_type) {
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1874 case CODEC_TYPE_VIDEO:
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
1875 ret = avcodec_decode_video(st->codec, &picture,
3002
d6f8c7cc47f9 Remove incorrect casts that should have never been there.
michael
parents: 2973
diff changeset
1876 &got_picture, data, size);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1877 break;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1878 case CODEC_TYPE_AUDIO:
1818
0c28d35086f5 use avcodec_decode_audio2
bcoudurier
parents: 1804
diff changeset
1879 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
0c28d35086f5 use avcodec_decode_audio2
bcoudurier
parents: 1804
diff changeset
1880 samples = av_malloc(data_size);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1881 if (!samples)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1882 goto fail;
1818
0c28d35086f5 use avcodec_decode_audio2
bcoudurier
parents: 1804
diff changeset
1883 ret = avcodec_decode_audio2(st->codec, samples,
3002
d6f8c7cc47f9 Remove incorrect casts that should have never been there.
michael
parents: 2973
diff changeset
1884 &data_size, data, size);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1885 av_free(samples);
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1886 break;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1887 default:
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1888 break;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1889 }
737
119ac74d1c49 PIX_FMT_NONE and related fixes
michael
parents: 717
diff changeset
1890 }
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1891 fail:
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1892 return ret;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1893 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1894
2243
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1895 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1896 {
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1897 while (tags->id != CODEC_ID_NONE) {
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1898 if (tags->id == id)
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1899 return tags->tag;
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1900 tags++;
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1901 }
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1902 return 0;
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1903 }
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1904
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1905 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1906 {
2286
5fca908f82ea try exact match before case insensitive match in codec_get_id
michael
parents: 2281
diff changeset
1907 int i;
5fca908f82ea try exact match before case insensitive match in codec_get_id
michael
parents: 2281
diff changeset
1908 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
5fca908f82ea try exact match before case insensitive match in codec_get_id
michael
parents: 2281
diff changeset
1909 if(tag == tags[i].tag)
5fca908f82ea try exact match before case insensitive match in codec_get_id
michael
parents: 2281
diff changeset
1910 return tags[i].id;
5fca908f82ea try exact match before case insensitive match in codec_get_id
michael
parents: 2281
diff changeset
1911 }
5fca908f82ea try exact match before case insensitive match in codec_get_id
michael
parents: 2281
diff changeset
1912 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
5fca908f82ea try exact match before case insensitive match in codec_get_id
michael
parents: 2281
diff changeset
1913 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
5fca908f82ea try exact match before case insensitive match in codec_get_id
michael
parents: 2281
diff changeset
1914 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
5fca908f82ea try exact match before case insensitive match in codec_get_id
michael
parents: 2281
diff changeset
1915 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
5fca908f82ea try exact match before case insensitive match in codec_get_id
michael
parents: 2281
diff changeset
1916 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
5fca908f82ea try exact match before case insensitive match in codec_get_id
michael
parents: 2281
diff changeset
1917 return tags[i].id;
2243
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1918 }
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1919 return CODEC_ID_NONE;
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1920 }
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1921
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1922 unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1923 {
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1924 int i;
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1925 for(i=0; tags && tags[i]; i++){
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1926 int tag= codec_get_tag(tags[i], id);
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1927 if(tag) return tag;
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1928 }
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1929 return 0;
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1930 }
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1931
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1932 enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1933 {
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1934 int i;
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1935 for(i=0; tags && tags[i]; i++){
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1936 enum CodecID id= codec_get_id(tags[i], tag);
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1937 if(id!=CODEC_ID_NONE) return id;
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1938 }
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1939 return CODEC_ID_NONE;
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1940 }
639597604897 Move public API functions av_codec_get_tag() and av_codec_get_id()
aurel
parents: 2223
diff changeset
1941
3341
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1942 static void compute_chapters_end(AVFormatContext *s)
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1943 {
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1944 unsigned int i;
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1945
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1946 for (i=0; i+1<s->nb_chapters; i++)
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1947 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1948 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1949 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1950 s->chapters[i]->end = s->chapters[i+1]->start;
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1951 }
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1952
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1953 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1954 assert(s->start_time != AV_NOPTS_VALUE);
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1955 assert(s->duration > 0);
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1956 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1957 AV_TIME_BASE_Q,
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1958 s->chapters[i]->time_base);
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1959 }
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1960 }
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
1961
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1962 /* absolute maximum size we read until we abort */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1963 #define MAX_READ_SIZE 5000000
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1964
1569
d440e6a53bae the next r_frame_rate try ...
michael
parents: 1567
diff changeset
1965 #define MAX_STD_TIMEBASES (60*12+5)
1566
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
1966 static int get_std_framerate(int i){
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
1967 if(i<60*12) return i*1001;
3769
93d4898d9b6e Mark several libavformat arrays const
reimar
parents: 3758
diff changeset
1968 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1566
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
1969 }
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
1970
2861
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1971 /*
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1972 * Is the time base unreliable.
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1973 * This is a heuristic to balance between quick acceptance of the values in
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1974 * the headers vs. some extra checks.
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
1975 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
1976 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2861
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1977 * And there are "variable" fps files this needs to detect as well.
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1978 */
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1979 static int tb_unreliable(AVCodecContext *c){
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1980 if( c->time_base.den >= 101L*c->time_base.num
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1981 || c->time_base.den < 5L*c->time_base.num
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1982 /* || c->codec_tag == ff_get_fourcc("DIVX")
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1983 || c->codec_tag == ff_get_fourcc("XVID")*/
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1984 || c->codec_id == CODEC_ID_MPEG2VIDEO)
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1985 return 1;
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1986 return 0;
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1987 }
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
1988
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1989 int av_find_stream_info(AVFormatContext *ic)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1990 {
927
a28b47d5238a improve fps guessing code
michael
parents: 926
diff changeset
1991 int i, count, ret, read_size, j;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
1992 AVStream *st;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
1993 AVPacket pkt1, *pkt;
620
7dbdbe073bcd try to guess the fps if they are variable
michael
parents: 618
diff changeset
1994 int64_t last_dts[MAX_STREAMS];
750
ba67f8c7f8f9 better r_frame_rate guessing code
michael
parents: 748
diff changeset
1995 int duration_count[MAX_STREAMS]={0};
1837
7b64dd81b38d replace the auto array "duration_error" with a malloced array.
gpoirier
parents: 1824
diff changeset
1996 double (*duration_error)[MAX_STD_TIMEBASES];
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
1997 offset_t old_offset = url_ftell(ic->pb);
1906
330115d147d6 remove codec_info_duration/nb_frames from AVStream
bcoudurier
parents: 1840
diff changeset
1998 int64_t codec_info_duration[MAX_STREAMS]={0};
330115d147d6 remove codec_info_duration/nb_frames from AVStream
bcoudurier
parents: 1840
diff changeset
1999 int codec_info_nb_frames[MAX_STREAMS]={0};
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2000
1837
7b64dd81b38d replace the auto array "duration_error" with a malloced array.
gpoirier
parents: 1824
diff changeset
2001 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2273
7eb456c4ed8a Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents: 2266
diff changeset
2002 if (!duration_error) return AVERROR(ENOMEM);
1837
7b64dd81b38d replace the auto array "duration_error" with a malloced array.
gpoirier
parents: 1824
diff changeset
2003
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
2004 for(i=0;i<ic->nb_streams;i++) {
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
2005 st = ic->streams[i];
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2006 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
2007 /* if(!st->time_base.num)
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
2008 st->time_base= */
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2009 if(!st->codec->time_base.num)
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2010 st->codec->time_base= st->time_base;
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
2011 }
797
f5a231a9a2f1 support changing in bitstream global headers into extradata style and back
michael
parents: 786
diff changeset
2012 //only for the split stuff
f5a231a9a2f1 support changing in bitstream global headers into extradata style and back
michael
parents: 786
diff changeset
2013 if (!st->parser) {
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2014 st->parser = av_parser_init(st->codec->codec_id);
2023
a3e79d6e4e3c add an enum for need_parsing
aurel
parents: 2020
diff changeset
2015 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
842
43210d766412 parse pict_type for streams in avi
michael
parents: 841
diff changeset
2016 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
43210d766412 parse pict_type for streams in avi
michael
parents: 841
diff changeset
2017 }
797
f5a231a9a2f1 support changing in bitstream global headers into extradata style and back
michael
parents: 786
diff changeset
2018 }
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
2019 }
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
2020
620
7dbdbe073bcd try to guess the fps if they are variable
michael
parents: 618
diff changeset
2021 for(i=0;i<MAX_STREAMS;i++){
7dbdbe073bcd try to guess the fps if they are variable
michael
parents: 618
diff changeset
2022 last_dts[i]= AV_NOPTS_VALUE;
7dbdbe073bcd try to guess the fps if they are variable
michael
parents: 618
diff changeset
2023 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2024
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2025 count = 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2026 read_size = 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2027 for(;;) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2028 /* check if one codec still needs to be handled */
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2029 for(i=0;i<ic->nb_streams;i++) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2030 st = ic->streams[i];
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2031 if (!has_codec_parameters(st->codec))
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2032 break;
624
e7b64333f116 guess fps for the variable fps case
michael
parents: 620
diff changeset
2033 /* variable fps and no guess at the real fps */
2861
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
2034 if( tb_unreliable(st->codec)
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2035 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
624
e7b64333f116 guess fps for the variable fps case
michael
parents: 620
diff changeset
2036 break;
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2037 if(st->parser && st->parser->parser->split && !st->codec->extradata)
797
f5a231a9a2f1 support changing in bitstream global headers into extradata style and back
michael
parents: 786
diff changeset
2038 break;
2300
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
2039 if(st->first_dts == AV_NOPTS_VALUE)
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
2040 break;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2041 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2042 if (i == ic->nb_streams) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2043 /* NOTE: if the format has no header, then we need to read
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2044 some packets to get most of the streams, so we cannot
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2045 stop here */
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2046 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2047 /* if we found the info for all the codecs, we can stop */
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2048 ret = count;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2049 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2050 }
1327
dac7743ba1ee dont ignore MAX_READ_SIZE
michael
parents: 1322
diff changeset
2051 }
1328
73f30bfae745 reindent
michael
parents: 1327
diff changeset
2052 /* we did not get all the codec info, but we read too much data */
73f30bfae745 reindent
michael
parents: 1327
diff changeset
2053 if (read_size >= MAX_READ_SIZE) {
73f30bfae745 reindent
michael
parents: 1327
diff changeset
2054 ret = count;
73f30bfae745 reindent
michael
parents: 1327
diff changeset
2055 break;
73f30bfae745 reindent
michael
parents: 1327
diff changeset
2056 }
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2057
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2058 /* NOTE: a new stream can be added there if no header in file
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2059 (AVFMTCTX_NOHEADER) */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2060 ret = av_read_frame_internal(ic, &pkt1);
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2061 if (ret < 0) {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2062 /* EOF or error */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2063 ret = -1; /* we could not have all the codec parameters before EOF */
651
6a5ba24b2c6b fixing demuxing for short files where the framerate detection failed
michael
parents: 643
diff changeset
2064 for(i=0;i<ic->nb_streams;i++) {
6a5ba24b2c6b fixing demuxing for short files where the framerate detection failed
michael
parents: 643
diff changeset
2065 st = ic->streams[i];
1018
bddcb32bde33 provide more info on which streams lack codec parameters
michael
parents: 1003
diff changeset
2066 if (!has_codec_parameters(st->codec)){
bddcb32bde33 provide more info on which streams lack codec parameters
michael
parents: 1003
diff changeset
2067 char buf[256];
bddcb32bde33 provide more info on which streams lack codec parameters
michael
parents: 1003
diff changeset
2068 avcodec_string(buf, sizeof(buf), st->codec, 0);
bddcb32bde33 provide more info on which streams lack codec parameters
michael
parents: 1003
diff changeset
2069 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1139
ff241582890f do not fail av_find_stream_info() if params for all streams could not be found
mru
parents: 1135
diff changeset
2070 } else {
ff241582890f do not fail av_find_stream_info() if params for all streams could not be found
mru
parents: 1135
diff changeset
2071 ret = 0;
1018
bddcb32bde33 provide more info on which streams lack codec parameters
michael
parents: 1003
diff changeset
2072 }
651
6a5ba24b2c6b fixing demuxing for short files where the framerate detection failed
michael
parents: 643
diff changeset
2073 }
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2074 break;
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2075 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2076
3698
b7e347127897 Maintain pointer to end of AVFormatContext.packet_buffer list
mru
parents: 3612
diff changeset
2077 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
3590
b22fa30c033e Fix a mem leak in av_find_stream_info().
benoit
parents: 3582
diff changeset
2078 if(av_dup_packet(pkt) < 0) {
b22fa30c033e Fix a mem leak in av_find_stream_info().
benoit
parents: 3582
diff changeset
2079 av_free(duration_error);
2297
acdc747b9ff3 move code which adds a AVPacket into the packet buffer into its own function
michael
parents: 2295
diff changeset
2080 return AVERROR(ENOMEM);
3590
b22fa30c033e Fix a mem leak in av_find_stream_info().
benoit
parents: 3582
diff changeset
2081 }
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2082
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2083 read_size += pkt->size;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2084
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2085 st = ic->streams[pkt->stream_index];
1906
330115d147d6 remove codec_info_duration/nb_frames from AVStream
bcoudurier
parents: 1840
diff changeset
2086 if(codec_info_nb_frames[st->index]>1)
330115d147d6 remove codec_info_duration/nb_frames from AVStream
bcoudurier
parents: 1840
diff changeset
2087 codec_info_duration[st->index] += pkt->duration;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2088 if (pkt->duration != 0)
1906
330115d147d6 remove codec_info_duration/nb_frames from AVStream
bcoudurier
parents: 1840
diff changeset
2089 codec_info_nb_frames[st->index]++;
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2090
772
d3cec742f7c0 av_find_stream_info() end check fixes
michael
parents: 764
diff changeset
2091 {
750
ba67f8c7f8f9 better r_frame_rate guessing code
michael
parents: 748
diff changeset
2092 int index= pkt->stream_index;
ba67f8c7f8f9 better r_frame_rate guessing code
michael
parents: 748
diff changeset
2093 int64_t last= last_dts[index];
ba67f8c7f8f9 better r_frame_rate guessing code
michael
parents: 748
diff changeset
2094 int64_t duration= pkt->dts - last;
ba67f8c7f8f9 better r_frame_rate guessing code
michael
parents: 748
diff changeset
2095
ba67f8c7f8f9 better r_frame_rate guessing code
michael
parents: 748
diff changeset
2096 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1566
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2097 double dur= duration * av_q2d(st->time_base);
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2098
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2099 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2100 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1616
dfe8b8bd6833 nth try of getting the frame rate detecton working
michael
parents: 1611
diff changeset
2101 if(duration_count[index] < 2)
3118
4410d9725469 do not reset duration_error for all streams, only reset current stream, fix wrong_fps.gxf
bcoudurier
parents: 3063
diff changeset
2102 memset(duration_error[index], 0, sizeof(*duration_error));
1617
ad71e733bc20 indention
michael
parents: 1616
diff changeset
2103 for(i=1; i<MAX_STD_TIMEBASES; i++){
ad71e733bc20 indention
michael
parents: 1616
diff changeset
2104 int framerate= get_std_framerate(i);
ad71e733bc20 indention
michael
parents: 1616
diff changeset
2105 int ticks= lrintf(dur*framerate/(1001*12));
ad71e733bc20 indention
michael
parents: 1616
diff changeset
2106 double error= dur - ticks*1001*12/(double)framerate;
ad71e733bc20 indention
michael
parents: 1616
diff changeset
2107 duration_error[index][i] += error*error;
ad71e733bc20 indention
michael
parents: 1616
diff changeset
2108 }
1566
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2109 duration_count[index]++;
620
7dbdbe073bcd try to guess the fps if they are variable
michael
parents: 618
diff changeset
2110 }
1569
d440e6a53bae the next r_frame_rate try ...
michael
parents: 1567
diff changeset
2111 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
d440e6a53bae the next r_frame_rate try ...
michael
parents: 1567
diff changeset
2112 last_dts[pkt->stream_index]= pkt->dts;
620
7dbdbe073bcd try to guess the fps if they are variable
michael
parents: 618
diff changeset
2113 }
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2114 if(st->parser && st->parser->parser->split && !st->codec->extradata){
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2115 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
797
f5a231a9a2f1 support changing in bitstream global headers into extradata style and back
michael
parents: 786
diff changeset
2116 if(i){
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2117 st->codec->extradata_size= i;
1141
ef9bf68071d3 extradata may be used as bitstream reader input so allocate with padding
mru
parents: 1139
diff changeset
2118 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2119 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1141
ef9bf68071d3 extradata may be used as bitstream reader input so allocate with padding
mru
parents: 1139
diff changeset
2120 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
797
f5a231a9a2f1 support changing in bitstream global headers into extradata style and back
michael
parents: 786
diff changeset
2121 }
f5a231a9a2f1 support changing in bitstream global headers into extradata style and back
michael
parents: 786
diff changeset
2122 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2123
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2124 /* if still no information, we try to open the codec and to
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2125 decompress the frame. We try to avoid that in most cases as
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2126 it takes longer and uses more memory. For MPEG-4, we need to
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2127 decompress for QuickTime. */
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2128 if (!has_codec_parameters(st->codec) /*&&
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2129 (st->codec->codec_id == CODEC_ID_FLV1 ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2130 st->codec->codec_id == CODEC_ID_H264 ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2131 st->codec->codec_id == CODEC_ID_H263 ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2132 st->codec->codec_id == CODEC_ID_H261 ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2133 st->codec->codec_id == CODEC_ID_VORBIS ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2134 st->codec->codec_id == CODEC_ID_MJPEG ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2135 st->codec->codec_id == CODEC_ID_PNG ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2136 st->codec->codec_id == CODEC_ID_PAM ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2137 st->codec->codec_id == CODEC_ID_PGM ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2138 st->codec->codec_id == CODEC_ID_PGMYUV ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2139 st->codec->codec_id == CODEC_ID_PBM ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2140 st->codec->codec_id == CODEC_ID_PPM ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2141 st->codec->codec_id == CODEC_ID_SHORTEN ||
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2142 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2143 try_decode_frame(st, pkt->data, pkt->size);
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2144
2253
3677c1667194 avoid division by zero in av_find_stream_info() when no time base is set
mru
parents: 2243
diff changeset
2145 if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2146 break;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2147 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2148 count++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2149 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2150
3142
8891d470ada3 typo fixes
diego
parents: 3128
diff changeset
2151 // close codecs which were opened in try_decode_frame()
801
bca2334ff177 dont open and close codec at every call of try_decode_frame() as this is not only slow but also fails if the previous frame is needed for setting some parameters correctly
michael
parents: 797
diff changeset
2152 for(i=0;i<ic->nb_streams;i++) {
bca2334ff177 dont open and close codec at every call of try_decode_frame() as this is not only slow but also fails if the previous frame is needed for setting some parameters correctly
michael
parents: 797
diff changeset
2153 st = ic->streams[i];
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2154 if(st->codec->codec)
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2155 avcodec_close(st->codec);
801
bca2334ff177 dont open and close codec at every call of try_decode_frame() as this is not only slow but also fails if the previous frame is needed for setting some parameters correctly
michael
parents: 797
diff changeset
2156 }
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2157 for(i=0;i<ic->nb_streams;i++) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2158 st = ic->streams[i];
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2159 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2160 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2161 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
620
7dbdbe073bcd try to guess the fps if they are variable
michael
parents: 618
diff changeset
2162
1616
dfe8b8bd6833 nth try of getting the frame rate detecton working
michael
parents: 1611
diff changeset
2163 if(duration_count[i]
2861
e6e210e4581d Fix detected fps for old divx/xvid.
michael
parents: 2854
diff changeset
2164 && tb_unreliable(st->codec) /*&&
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2165 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
1566
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2166 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2167 double best_error= 2*av_q2d(st->time_base);
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2168 best_error= best_error*best_error*duration_count[i]*1000*12*30;
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2169
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2170 for(j=1; j<MAX_STD_TIMEBASES; j++){
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2171 double error= duration_error[i][j] * get_std_framerate(j);
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2172 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2173 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
927
a28b47d5238a improve fps guessing code
michael
parents: 926
diff changeset
2174 if(error < best_error){
a28b47d5238a improve fps guessing code
michael
parents: 926
diff changeset
2175 best_error= error;
1566
bef95ed80667 rewrite r_frame_rate selectioon code again
michael
parents: 1557
diff changeset
2176 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
927
a28b47d5238a improve fps guessing code
michael
parents: 926
diff changeset
2177 }
750
ba67f8c7f8f9 better r_frame_rate guessing code
michael
parents: 748
diff changeset
2178 }
620
7dbdbe073bcd try to guess the fps if they are variable
michael
parents: 618
diff changeset
2179 }
7dbdbe073bcd try to guess the fps if they are variable
michael
parents: 618
diff changeset
2180
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
2181 if (!st->r_frame_rate.num){
1351
244017c6b2ae fix r_frame_rate detection in mpeg4 streams with non integer fps
michael
parents: 1330
diff changeset
2182 if( st->codec->time_base.den * (int64_t)st->time_base.num
244017c6b2ae fix r_frame_rate detection in mpeg4 streams with non integer fps
michael
parents: 1330
diff changeset
2183 <= st->codec->time_base.num * (int64_t)st->time_base.den){
244017c6b2ae fix r_frame_rate detection in mpeg4 streams with non integer fps
michael
parents: 1330
diff changeset
2184 st->r_frame_rate.num = st->codec->time_base.den;
244017c6b2ae fix r_frame_rate detection in mpeg4 streams with non integer fps
michael
parents: 1330
diff changeset
2185 st->r_frame_rate.den = st->codec->time_base.num;
244017c6b2ae fix r_frame_rate detection in mpeg4 streams with non integer fps
michael
parents: 1330
diff changeset
2186 }else{
244017c6b2ae fix r_frame_rate detection in mpeg4 streams with non integer fps
michael
parents: 1330
diff changeset
2187 st->r_frame_rate.num = st->time_base.den;
244017c6b2ae fix r_frame_rate detection in mpeg4 streams with non integer fps
michael
parents: 1330
diff changeset
2188 st->r_frame_rate.den = st->time_base.num;
244017c6b2ae fix r_frame_rate detection in mpeg4 streams with non integer fps
michael
parents: 1330
diff changeset
2189 }
85
25062c9b1f86 per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents: 75
diff changeset
2190 }
1804
302115721ef5 try to fill in missing bits_per_sample
michael
parents: 1787
diff changeset
2191 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
302115721ef5 try to fill in missing bits_per_sample
michael
parents: 1787
diff changeset
2192 if(!st->codec->bits_per_sample)
302115721ef5 try to fill in missing bits_per_sample
michael
parents: 1787
diff changeset
2193 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2194 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2195 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2196
1755
41160bae24b5 Fix audio corruption when cutting.
takis
parents: 1751
diff changeset
2197 av_estimate_timings(ic, old_offset);
2018
0d9b233dff9b DVR-MS probe audio format
benoit
parents: 2001
diff changeset
2198
3341
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
2199 compute_chapters_end(ic);
13333599b04b compute the end of all chapters when end is not specified in the container
aurel
parents: 3340
diff changeset
2200
468
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2201 #if 0
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2202 /* correct DTS for B-frame streams with no timestamps */
468
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2203 for(i=0;i<ic->nb_streams;i++) {
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2204 st = ic->streams[i];
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2205 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
468
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2206 if(b-frames){
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2207 ppktl = &ic->packet_buffer;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2208 while(ppkt1){
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2209 if(ppkt1->stream_index != i)
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2210 continue;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2211 if(ppkt1->pkt->dts < 0)
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2212 break;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2213 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2214 break;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2215 ppkt1->pkt->dts -= delta;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2216 ppkt1= ppkt1->next;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2217 }
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2218 if(ppkt1)
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2219 continue;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2220 st->cur_dts -= delta;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2221 }
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2222 }
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2223 }
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2224 #endif
1837
7b64dd81b38d replace the auto array "duration_error" with a malloced array.
gpoirier
parents: 1824
diff changeset
2225
7b64dd81b38d replace the auto array "duration_error" with a malloced array.
gpoirier
parents: 1824
diff changeset
2226 av_free(duration_error);
7b64dd81b38d replace the auto array "duration_error" with a malloced array.
gpoirier
parents: 1824
diff changeset
2227
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2228 return ret;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2229 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2230
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2231 /*******************************************************/
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2232
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2233 int av_read_play(AVFormatContext *s)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2234 {
2827
f717dd23fc23 Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents: 2812
diff changeset
2235 if (s->iformat->read_play)
f717dd23fc23 Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents: 2812
diff changeset
2236 return s->iformat->read_play(s);
2842
bc317b8d7090 remove double check of pb->read_seek
aurel
parents: 2841
diff changeset
2237 if (s->pb)
2839
b51319dd86e5 Merge recently added and still unused play and pause functions.
michael
parents: 2835
diff changeset
2238 return av_url_read_fpause(s->pb, 0);
2827
f717dd23fc23 Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents: 2812
diff changeset
2239 return AVERROR(ENOSYS);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2240 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2241
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2242 int av_read_pause(AVFormatContext *s)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2243 {
2827
f717dd23fc23 Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents: 2812
diff changeset
2244 if (s->iformat->read_pause)
f717dd23fc23 Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents: 2812
diff changeset
2245 return s->iformat->read_pause(s);
2842
bc317b8d7090 remove double check of pb->read_seek
aurel
parents: 2841
diff changeset
2246 if (s->pb)
2839
b51319dd86e5 Merge recently added and still unused play and pause functions.
michael
parents: 2835
diff changeset
2247 return av_url_read_fpause(s->pb, 1);
2827
f717dd23fc23 Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents: 2812
diff changeset
2248 return AVERROR(ENOSYS);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2249 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2250
2835
b158768c5352 Add a av_close_input_stream function
reimar
parents: 2832
diff changeset
2251 void av_close_input_stream(AVFormatContext *s)
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2252 {
2830
d7b2ac8d796d Simplify av_close_input_file similarly to av_open_input_file previously
reimar
parents: 2829
diff changeset
2253 int i;
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
2254 AVStream *st;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2255
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2256 /* free previous packet */
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2257 if (s->cur_st && s->cur_st->parser)
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2258 av_free_packet(&s->cur_pkt);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2259
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2260 if (s->iformat->read_close)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2261 s->iformat->read_close(s);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2262 for(i=0;i<s->nb_streams;i++) {
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
2263 /* free all data in a stream component */
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
2264 st = s->streams[i];
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2265 if (st->parser) {
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2266 av_parser_close(st->parser);
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2267 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2268 av_free(st->index_entries);
1120
801d4a5cf353 free codec extradata in av_close_input_file
mru
parents: 1119
diff changeset
2269 av_free(st->codec->extradata);
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2270 av_free(st->codec);
2973
910ac68ab3b5 Add support for Matroska attachments.
aurel
parents: 2962
diff changeset
2271 av_free(st->filename);
3487
2f191d610db9 uniformize AVStream->priv_data freeing in av_close_input_stream
bcoudurier
parents: 3486
diff changeset
2272 av_free(st->priv_data);
293
62cec412a186 make AVFMT_NOHEADER flag dynamic - added av_open_input_stream()
bellard
parents: 290
diff changeset
2273 av_free(st);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2274 }
2573
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2275 for(i=s->nb_programs-1; i>=0; i--) {
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2276 av_freep(&s->programs[i]->provider_name);
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2277 av_freep(&s->programs[i]->name);
2650
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2278 av_freep(&s->programs[i]->stream_index);
2573
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2279 av_freep(&s->programs[i]);
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2280 }
3248
7fe0c156ed74 minor memleak
michael
parents: 3230
diff changeset
2281 av_freep(&s->programs);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
2282 flush_packet_queue(s);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2283 av_freep(&s->priv_data);
3328
b228cfb5a4f5 s/num_chapters/nb_chapters/ all other similar variables are called nb_*.
michael
parents: 3327
diff changeset
2284 while(s->nb_chapters--) {
b228cfb5a4f5 s/num_chapters/nb_chapters/ all other similar variables are called nb_*.
michael
parents: 3327
diff changeset
2285 av_free(s->chapters[s->nb_chapters]->title);
b228cfb5a4f5 s/num_chapters/nb_chapters/ all other similar variables are called nb_*.
michael
parents: 3327
diff changeset
2286 av_free(s->chapters[s->nb_chapters]);
3314
724f338005d4 add support for chapters definition in lavf
aurel
parents: 3286
diff changeset
2287 }
724f338005d4 add support for chapters definition in lavf
aurel
parents: 3286
diff changeset
2288 av_freep(&s->chapters);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2289 av_free(s);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2290 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2291
2835
b158768c5352 Add a av_close_input_stream function
reimar
parents: 2832
diff changeset
2292 void av_close_input_file(AVFormatContext *s)
b158768c5352 Add a av_close_input_stream function
reimar
parents: 2832
diff changeset
2293 {
b158768c5352 Add a av_close_input_stream function
reimar
parents: 2832
diff changeset
2294 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
b158768c5352 Add a av_close_input_stream function
reimar
parents: 2832
diff changeset
2295 av_close_input_stream(s);
b158768c5352 Add a av_close_input_stream function
reimar
parents: 2832
diff changeset
2296 if (pb)
b158768c5352 Add a av_close_input_stream function
reimar
parents: 2832
diff changeset
2297 url_fclose(pb);
b158768c5352 Add a av_close_input_stream function
reimar
parents: 2832
diff changeset
2298 }
b158768c5352 Add a av_close_input_stream function
reimar
parents: 2832
diff changeset
2299
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2300 AVStream *av_new_stream(AVFormatContext *s, int id)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2301 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2302 AVStream *st;
1285
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2303 int i;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2304
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2305 if (s->nb_streams >= MAX_STREAMS)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2306 return NULL;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2307
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2308 st = av_mallocz(sizeof(AVStream));
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2309 if (!st)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2310 return NULL;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2311
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2312 st->codec= avcodec_alloc_context();
193
5079b6e20e91 no default bit rate if decoding
bellard
parents: 192
diff changeset
2313 if (s->iformat) {
5079b6e20e91 no default bit rate if decoding
bellard
parents: 192
diff changeset
2314 /* no default bitrate if decoding */
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2315 st->codec->bit_rate = 0;
193
5079b6e20e91 no default bit rate if decoding
bellard
parents: 192
diff changeset
2316 }
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2317 st->index = s->nb_streams;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2318 st->id = id;
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2319 st->start_time = AV_NOPTS_VALUE;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2320 st->duration = AV_NOPTS_VALUE;
3552
8bce09af18e6 Set cur_dts to 0 only during creating new streams and not every time cur_dts happens
michael
parents: 3537
diff changeset
2321 /* we set the current DTS to 0 so that formats without any timestamps
8bce09af18e6 Set cur_dts to 0 only during creating new streams and not every time cur_dts happens
michael
parents: 3537
diff changeset
2322 but durations get some timestamps, formats with some unknown
8bce09af18e6 Set cur_dts to 0 only during creating new streams and not every time cur_dts happens
michael
parents: 3537
diff changeset
2323 timestamps have their first few packets buffered and the
8bce09af18e6 Set cur_dts to 0 only during creating new streams and not every time cur_dts happens
michael
parents: 3537
diff changeset
2324 timestamps corrected before they are returned to the user */
8bce09af18e6 Set cur_dts to 0 only during creating new streams and not every time cur_dts happens
michael
parents: 3537
diff changeset
2325 st->cur_dts = 0;
2300
9c8cfadff191 correct initial timestamps which have AV_NOPTS_VALUE
michael
parents: 2297
diff changeset
2326 st->first_dts = AV_NOPTS_VALUE;
462
b69898ffc92a move time_base (pts_num/pts_den) from AVFormatContext -> AVStream
michael
parents: 453
diff changeset
2327
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2328 /* default pts setting is MPEG-like */
462
b69898ffc92a move time_base (pts_num/pts_den) from AVFormatContext -> AVStream
michael
parents: 453
diff changeset
2329 av_set_pts_info(st, 33, 1, 90000);
3058
33ecae58665a revert 12156
michael
parents: 3056
diff changeset
2330 st->last_IP_pts = AV_NOPTS_VALUE;
1285
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2331 for(i=0; i<MAX_REORDER_DELAY+1; i++)
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2332 st->pts_buffer[i]= AV_NOPTS_VALUE;
462
b69898ffc92a move time_base (pts_num/pts_den) from AVFormatContext -> AVStream
michael
parents: 453
diff changeset
2333
3758
e966560661e5 export sample_aspect_ratio read by the demuxer in a separate field
aurel
parents: 3718
diff changeset
2334 st->sample_aspect_ratio = (AVRational){0,1};
e966560661e5 export sample_aspect_ratio read by the demuxer in a separate field
aurel
parents: 3718
diff changeset
2335
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2336 s->streams[s->nb_streams++] = st;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2337 return st;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2338 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2339
2573
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2340 AVProgram *av_new_program(AVFormatContext *ac, int id)
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2341 {
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2342 AVProgram *program=NULL;
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2343 int i;
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2344
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2345 #ifdef DEBUG_SI
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2346 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2347 #endif
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2348
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2349 for(i=0; i<ac->nb_programs; i++)
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2350 if(ac->programs[i]->id == id)
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2351 program = ac->programs[i];
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2352
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2353 if(!program){
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2354 program = av_mallocz(sizeof(AVProgram));
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2355 if (!program)
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2356 return NULL;
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2357 dynarray_add(&ac->programs, &ac->nb_programs, program);
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2358 program->discard = AVDISCARD_NONE;
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2359 }
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2360 program->id = id;
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2361
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2362 return program;
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2363 }
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2364
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2365 void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2366 {
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2367 assert(!provider_name == !name);
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2368 if(name){
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2369 av_free(program->provider_name);
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2370 av_free(program-> name);
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2371 program->provider_name = av_strdup(provider_name);
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2372 program-> name = av_strdup( name);
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2373 }
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2374 }
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2375
3334
7a823a401282 Pass time_base as argument to new_chapter() as well.
michael
parents: 3332
diff changeset
2376 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3314
724f338005d4 add support for chapters definition in lavf
aurel
parents: 3286
diff changeset
2377 {
3323
4bf98e198eec Add id to AVChapter, untested (where do i find matroska files with chapters?).
michael
parents: 3318
diff changeset
2378 AVChapter *chapter = NULL;
4bf98e198eec Add id to AVChapter, untested (where do i find matroska files with chapters?).
michael
parents: 3318
diff changeset
2379 int i;
4bf98e198eec Add id to AVChapter, untested (where do i find matroska files with chapters?).
michael
parents: 3318
diff changeset
2380
3328
b228cfb5a4f5 s/num_chapters/nb_chapters/ all other similar variables are called nb_*.
michael
parents: 3327
diff changeset
2381 for(i=0; i<s->nb_chapters; i++)
3323
4bf98e198eec Add id to AVChapter, untested (where do i find matroska files with chapters?).
michael
parents: 3318
diff changeset
2382 if(s->chapters[i]->id == id)
4bf98e198eec Add id to AVChapter, untested (where do i find matroska files with chapters?).
michael
parents: 3318
diff changeset
2383 chapter = s->chapters[i];
4bf98e198eec Add id to AVChapter, untested (where do i find matroska files with chapters?).
michael
parents: 3318
diff changeset
2384
4bf98e198eec Add id to AVChapter, untested (where do i find matroska files with chapters?).
michael
parents: 3318
diff changeset
2385 if(!chapter){
4bf98e198eec Add id to AVChapter, untested (where do i find matroska files with chapters?).
michael
parents: 3318
diff changeset
2386 chapter= av_mallocz(sizeof(AVChapter));
3324
michael
parents: 3323
diff changeset
2387 if(!chapter)
3330
374e74567a4e Make ff_new_chapter() return AVChapter instead of int so its consistant with
michael
parents: 3328
diff changeset
2388 return NULL;
3328
b228cfb5a4f5 s/num_chapters/nb_chapters/ all other similar variables are called nb_*.
michael
parents: 3327
diff changeset
2389 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3323
4bf98e198eec Add id to AVChapter, untested (where do i find matroska files with chapters?).
michael
parents: 3318
diff changeset
2390 }
3340
670503410b6b cosmetics: indentation
aurel
parents: 3339
diff changeset
2391 av_free(chapter->title);
3326
michael
parents: 3325
diff changeset
2392 chapter->title = av_strdup(title);
3323
4bf98e198eec Add id to AVChapter, untested (where do i find matroska files with chapters?).
michael
parents: 3318
diff changeset
2393 chapter->id = id;
3334
7a823a401282 Pass time_base as argument to new_chapter() as well.
michael
parents: 3332
diff changeset
2394 chapter->time_base= time_base;
3314
724f338005d4 add support for chapters definition in lavf
aurel
parents: 3286
diff changeset
2395 chapter->start = start;
3327
87e48733847c vertical align
michael
parents: 3326
diff changeset
2396 chapter->end = end;
3314
724f338005d4 add support for chapters definition in lavf
aurel
parents: 3286
diff changeset
2397
3330
374e74567a4e Make ff_new_chapter() return AVChapter instead of int so its consistant with
michael
parents: 3328
diff changeset
2398 return chapter;
3314
724f338005d4 add support for chapters definition in lavf
aurel
parents: 3286
diff changeset
2399 }
2573
2842354cb9a4 Added definition and utility functions to handle AVProgram(s) in AVFormatContext
nicodvb
parents: 2559
diff changeset
2400
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2401 /************************************************************/
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2402 /* output media file */
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2403
20
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
2404 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
2405 {
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
2406 int ret;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2407
32
cd0155c9022e zero sized malloc patch by Roman Shaposhnick
bellard
parents: 30
diff changeset
2408 if (s->oformat->priv_data_size > 0) {
cd0155c9022e zero sized malloc patch by Roman Shaposhnick
bellard
parents: 30
diff changeset
2409 s->priv_data = av_mallocz(s->oformat->priv_data_size);
cd0155c9022e zero sized malloc patch by Roman Shaposhnick
bellard
parents: 30
diff changeset
2410 if (!s->priv_data)
2273
7eb456c4ed8a Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents: 2266
diff changeset
2411 return AVERROR(ENOMEM);
32
cd0155c9022e zero sized malloc patch by Roman Shaposhnick
bellard
parents: 30
diff changeset
2412 } else
cd0155c9022e zero sized malloc patch by Roman Shaposhnick
bellard
parents: 30
diff changeset
2413 s->priv_data = NULL;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2414
20
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
2415 if (s->oformat->set_parameters) {
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
2416 ret = s->oformat->set_parameters(s, ap);
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
2417 if (ret < 0)
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
2418 return ret;
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
2419 }
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
2420 return 0;
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
2421 }
3d52de18ecc3 added still image support
bellard
parents: 11
diff changeset
2422
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2423 int av_write_header(AVFormatContext *s)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2424 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2425 int ret, i;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2426 AVStream *st;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2427
839
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2428 // some sanity checks
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2429 for(i=0;i<s->nb_streams;i++) {
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2430 st = s->streams[i];
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2431
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2432 switch (st->codec->codec_type) {
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2433 case CODEC_TYPE_AUDIO:
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2434 if(st->codec->sample_rate<=0){
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2435 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2436 return -1;
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2437 }
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2438 break;
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2439 case CODEC_TYPE_VIDEO:
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2440 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2441 av_log(s, AV_LOG_ERROR, "time base not set\n");
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2442 return -1;
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2443 }
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2444 if(st->codec->width<=0 || st->codec->height<=0){
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2445 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2446 return -1;
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2447 }
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2448 break;
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2449 }
1681
23c911d09382 set codec_tag from codec_id if its not set and can be set based on the AVCodecTag tables
michael
parents: 1675
diff changeset
2450
23c911d09382 set codec_tag from codec_id if its not set and can be set based on the AVCodecTag tables
michael
parents: 1675
diff changeset
2451 if(s->oformat->codec_tag){
23c911d09382 set codec_tag from codec_id if its not set and can be set based on the AVCodecTag tables
michael
parents: 1675
diff changeset
2452 if(st->codec->codec_tag){
23c911d09382 set codec_tag from codec_id if its not set and can be set based on the AVCodecTag tables
michael
parents: 1675
diff changeset
2453 //FIXME
23c911d09382 set codec_tag from codec_id if its not set and can be set based on the AVCodecTag tables
michael
parents: 1675
diff changeset
2454 //check that tag + id is in the table
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2455 //if neither is in the table -> OK
1681
23c911d09382 set codec_tag from codec_id if its not set and can be set based on the AVCodecTag tables
michael
parents: 1675
diff changeset
2456 //if tag is in the table with another id -> FAIL
23c911d09382 set codec_tag from codec_id if its not set and can be set based on the AVCodecTag tables
michael
parents: 1675
diff changeset
2457 //if id is in the table with another tag -> FAIL unless strict < ?
23c911d09382 set codec_tag from codec_id if its not set and can be set based on the AVCodecTag tables
michael
parents: 1675
diff changeset
2458 }else
23c911d09382 set codec_tag from codec_id if its not set and can be set based on the AVCodecTag tables
michael
parents: 1675
diff changeset
2459 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
23c911d09382 set codec_tag from codec_id if its not set and can be set based on the AVCodecTag tables
michael
parents: 1675
diff changeset
2460 }
839
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2461 }
8f12a754d330 a few checks, seems i forgot to commit this
michael
parents: 838
diff changeset
2462
1625
f1ccbe0ad364 10l, only allocate priv_data if not already done
bcoudurier
parents: 1624
diff changeset
2463 if (!s->priv_data && s->oformat->priv_data_size > 0) {
1624
66f000bb4558 humm, actually do what's in the doxy
bcoudurier
parents: 1617
diff changeset
2464 s->priv_data = av_mallocz(s->oformat->priv_data_size);
66f000bb4558 humm, actually do what's in the doxy
bcoudurier
parents: 1617
diff changeset
2465 if (!s->priv_data)
2273
7eb456c4ed8a Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents: 2266
diff changeset
2466 return AVERROR(ENOMEM);
1625
f1ccbe0ad364 10l, only allocate priv_data if not already done
bcoudurier
parents: 1624
diff changeset
2467 }
1624
66f000bb4558 humm, actually do what's in the doxy
bcoudurier
parents: 1617
diff changeset
2468
869
8ff4e8ef8124 allow NULL write_header() and write_trailer()
michael
parents: 855
diff changeset
2469 if(s->oformat->write_header){
8ff4e8ef8124 allow NULL write_header() and write_trailer()
michael
parents: 855
diff changeset
2470 ret = s->oformat->write_header(s);
8ff4e8ef8124 allow NULL write_header() and write_trailer()
michael
parents: 855
diff changeset
2471 if (ret < 0)
8ff4e8ef8124 allow NULL write_header() and write_trailer()
michael
parents: 855
diff changeset
2472 return ret;
8ff4e8ef8124 allow NULL write_header() and write_trailer()
michael
parents: 855
diff changeset
2473 }
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2474
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2475 /* init PTS generation */
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2476 for(i=0;i<s->nb_streams;i++) {
840
8834d33b7ca1 minor fixes for invalid audio data patch by (Wolfram Gloger: wmglo, dent med uni-muenchen de)
michael
parents: 839
diff changeset
2477 int64_t den = AV_NOPTS_VALUE;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2478 st = s->streams[i];
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2479
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2480 switch (st->codec->codec_type) {
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2481 case CODEC_TYPE_AUDIO:
840
8834d33b7ca1 minor fixes for invalid audio data patch by (Wolfram Gloger: wmglo, dent med uni-muenchen de)
michael
parents: 839
diff changeset
2482 den = (int64_t)st->time_base.num * st->codec->sample_rate;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2483 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2484 case CODEC_TYPE_VIDEO:
840
8834d33b7ca1 minor fixes for invalid audio data patch by (Wolfram Gloger: wmglo, dent med uni-muenchen de)
michael
parents: 839
diff changeset
2485 den = (int64_t)st->time_base.num * st->codec->time_base.den;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2486 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2487 default:
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2488 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2489 }
840
8834d33b7ca1 minor fixes for invalid audio data patch by (Wolfram Gloger: wmglo, dent med uni-muenchen de)
michael
parents: 839
diff changeset
2490 if (den != AV_NOPTS_VALUE) {
8834d33b7ca1 minor fixes for invalid audio data patch by (Wolfram Gloger: wmglo, dent med uni-muenchen de)
michael
parents: 839
diff changeset
2491 if (den <= 0)
8834d33b7ca1 minor fixes for invalid audio data patch by (Wolfram Gloger: wmglo, dent med uni-muenchen de)
michael
parents: 839
diff changeset
2492 return AVERROR_INVALIDDATA;
8834d33b7ca1 minor fixes for invalid audio data patch by (Wolfram Gloger: wmglo, dent med uni-muenchen de)
michael
parents: 839
diff changeset
2493 av_frac_init(&st->pts, 0, 0, den);
8834d33b7ca1 minor fixes for invalid audio data patch by (Wolfram Gloger: wmglo, dent med uni-muenchen de)
michael
parents: 839
diff changeset
2494 }
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2495 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2496 return 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2497 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2498
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2499 //FIXME merge with compute_pkt_fields
617
1ca4877e42f3 some sanity checks on what is muxed, invalid timestamps in mpeg are very common and lead to strange errors in the mpeg muxer otherwise
michael
parents: 616
diff changeset
2500 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
1285
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2501 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2502 int num, den, frame_size, i;
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2503
1443
404048ea11bc Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents: 1442
diff changeset
2504 // av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2505
468
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2506 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2507 return -1;*/
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2508
468
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2509 /* duration field */
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2510 if (pkt->duration == 0) {
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2511 compute_frame_duration(&num, &den, st, NULL, pkt);
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2512 if (den && num) {
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2513 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2514 }
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2515 }
409
b6949d80b7a9 move zero size hack from ogg.c to utils.c
michael
parents: 406
diff changeset
2516
3502
322e2fb56ce8 Fill missing pts in during muxing when we know that they are equal to dts.
michael
parents: 3501
diff changeset
2517 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
322e2fb56ce8 Fill missing pts in during muxing when we know that they are equal to dts.
michael
parents: 3501
diff changeset
2518 pkt->pts= pkt->dts;
322e2fb56ce8 Fill missing pts in during muxing when we know that they are equal to dts.
michael
parents: 3501
diff changeset
2519
468
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2520 //XXX/FIXME this is a temporary hack until all encoders output pts
1285
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2521 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
468
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2522 pkt->dts=
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2523 // pkt->pts= st->cur_dts;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2524 pkt->pts= st->pts.val;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2525 }
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2526
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2527 //calculate dts from pts
3710
48a262da0100 Prevent dts generation code to be executed when delay is > MAX_REORDER_DELAY,
bcoudurier
parents: 3703
diff changeset
2528 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1285
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2529 st->pts_buffer[0]= pkt->pts;
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2530 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2531 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2532 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1442
c2b748de9b35 Rename SWAP macro to FFSWAP.
diego
parents: 1441
diff changeset
2533 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1285
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2534
b5226e679a31 fix b pyramid in mp4 muxing if no dts are provided to the muxer
michael
parents: 1279
diff changeset
2535 pkt->dts= st->pts_buffer[0];
468
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2536 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2537
617
1ca4877e42f3 some sanity checks on what is muxed, invalid timestamps in mpeg are very common and lead to strange errors in the mpeg muxer otherwise
michael
parents: 616
diff changeset
2538 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
3525
3fb9221edfe9 give context to av_log
bcoudurier
parents: 3509
diff changeset
2539 av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
617
1ca4877e42f3 some sanity checks on what is muxed, invalid timestamps in mpeg are very common and lead to strange errors in the mpeg muxer otherwise
michael
parents: 616
diff changeset
2540 return -1;
1ca4877e42f3 some sanity checks on what is muxed, invalid timestamps in mpeg are very common and lead to strange errors in the mpeg muxer otherwise
michael
parents: 616
diff changeset
2541 }
1ca4877e42f3 some sanity checks on what is muxed, invalid timestamps in mpeg are very common and lead to strange errors in the mpeg muxer otherwise
michael
parents: 616
diff changeset
2542 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3525
3fb9221edfe9 give context to av_log
bcoudurier
parents: 3509
diff changeset
2543 av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
617
1ca4877e42f3 some sanity checks on what is muxed, invalid timestamps in mpeg are very common and lead to strange errors in the mpeg muxer otherwise
michael
parents: 616
diff changeset
2544 return -1;
1ca4877e42f3 some sanity checks on what is muxed, invalid timestamps in mpeg are very common and lead to strange errors in the mpeg muxer otherwise
michael
parents: 616
diff changeset
2545 }
1ca4877e42f3 some sanity checks on what is muxed, invalid timestamps in mpeg are very common and lead to strange errors in the mpeg muxer otherwise
michael
parents: 616
diff changeset
2546
1443
404048ea11bc Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents: 1442
diff changeset
2547 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
468
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2548 st->cur_dts= pkt->dts;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2549 st->pts.val= pkt->dts;
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2550
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2551 /* update pts */
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2552 switch (st->codec->codec_type) {
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2553 case CODEC_TYPE_AUDIO:
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2554 frame_size = get_audio_frame_size(st->codec, pkt->size);
406
ea22a438ca79 fix obnoxious ogg_packet passing from encoder to muxer
michael
parents: 404
diff changeset
2555
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2556 /* HACK/FIXME, we skip the initial 0 size packets as they are most
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2557 likely equal to the encoder delay, but it would be better if we
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2558 had the real timestamps from the encoder */
468
60f897e8dd2d pass AVPacket into av_write_frame()
michael
parents: 466
diff changeset
2559 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
462
b69898ffc92a move time_base (pts_num/pts_den) from AVFormatContext -> AVStream
michael
parents: 453
diff changeset
2560 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2561 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2562 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2563 case CODEC_TYPE_VIDEO:
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2564 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2565 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2566 default:
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2567 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2568 }
617
1ca4877e42f3 some sanity checks on what is muxed, invalid timestamps in mpeg are very common and lead to strange errors in the mpeg muxer otherwise
michael
parents: 616
diff changeset
2569 return 0;
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2570 }
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2571
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2572 static void truncate_ts(AVStream *st, AVPacket *pkt){
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2573 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2574
547
b832a27355ec initial dts fix
michael
parents: 542
diff changeset
2575 // if(pkt->dts < 0)
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2576 // pkt->dts= 0; //this happens for low_delay=0 and B-frames, FIXME, needs further investigation about what we should do here
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2577
1555
5f829140788e cosmetics, remove braces, remove spaces just inside parens
bcoudurier
parents: 1554
diff changeset
2578 if (pkt->pts != AV_NOPTS_VALUE)
1554
1eaba8bc0ab1 do not truncate pts/dts if value is AV_NOPTS_VALUE, patch by Andy Parkins, andrew parkins at 360visiontechnology com
bcoudurier
parents: 1496
diff changeset
2579 pkt->pts &= pts_mask;
1555
5f829140788e cosmetics, remove braces, remove spaces just inside parens
bcoudurier
parents: 1554
diff changeset
2580 if (pkt->dts != AV_NOPTS_VALUE)
1554
1eaba8bc0ab1 do not truncate pts/dts if value is AV_NOPTS_VALUE, patch by Andy Parkins, andrew parkins at 360visiontechnology com
bcoudurier
parents: 1496
diff changeset
2581 pkt->dts &= pts_mask;
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2582 }
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2583
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2584 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2585 {
3429
670052821b9f Merge declaration and initialization.
ramiro
parents: 3423
diff changeset
2586 int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
670052821b9f Merge declaration and initialization.
ramiro
parents: 3423
diff changeset
2587
1245
e59b75051ded dont be too picky about timestampsbeing wrong if the destination container is without timestamps and raw of the raw video / raw audio sort
michael
parents: 1244
diff changeset
2588 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
617
1ca4877e42f3 some sanity checks on what is muxed, invalid timestamps in mpeg are very common and lead to strange errors in the mpeg muxer otherwise
michael
parents: 616
diff changeset
2589 return ret;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2590
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2591 truncate_ts(s->streams[pkt->stream_index], pkt);
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2592
554
e1f17fcfb92c write error handling
michael
parents: 547
diff changeset
2593 ret= s->oformat->write_packet(s, pkt);
e1f17fcfb92c write error handling
michael
parents: 547
diff changeset
2594 if(!ret)
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
2595 ret= url_ferror(s->pb);
554
e1f17fcfb92c write error handling
michael
parents: 547
diff changeset
2596 return ret;
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2597 }
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2598
1251
d06e5cb7fb52 export av_interleave_packet_per_dts
bcoudurier
parents: 1245
diff changeset
2599 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2600 AVPacketList *pktl, **next_point, *this_pktl;
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2601 int stream_count=0;
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2602 int streams[MAX_STREAMS];
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2603
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2604 if(pkt){
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2605 AVStream *st= s->streams[ pkt->stream_index];
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2606
804
6a0cd265adbb fix assertion failure
michael
parents: 802
diff changeset
2607 // assert(pkt->destruct != av_destruct_packet); //FIXME
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2608
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2609 this_pktl = av_mallocz(sizeof(AVPacketList));
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2610 this_pktl->pkt= *pkt;
804
6a0cd265adbb fix assertion failure
michael
parents: 802
diff changeset
2611 if(pkt->destruct == av_destruct_packet)
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2612 pkt->destruct= NULL; // not shared -> must keep original from being freed
804
6a0cd265adbb fix assertion failure
michael
parents: 802
diff changeset
2613 else
6a0cd265adbb fix assertion failure
michael
parents: 802
diff changeset
2614 av_dup_packet(&this_pktl->pkt); //shared -> must dup
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2615
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2616 next_point = &s->packet_buffer;
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2617 while(*next_point){
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2618 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2619 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2620 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2621 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2622 break;
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2623 next_point= &(*next_point)->next;
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2624 }
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2625 this_pktl->next= *next_point;
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2626 *next_point= this_pktl;
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2627 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2628
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2629 memset(streams, 0, sizeof(streams));
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2630 pktl= s->packet_buffer;
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2631 while(pktl){
1443
404048ea11bc Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents: 1442
diff changeset
2632 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2633 if(streams[ pktl->pkt.stream_index ] == 0)
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2634 stream_count++;
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2635 streams[ pktl->pkt.stream_index ]++;
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2636 pktl= pktl->next;
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2637 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2638
3485
99565673f94c Check if there is at least a stream before writing trailer.
benoit
parents: 3445
diff changeset
2639 if(stream_count && (s->nb_streams == stream_count || flush)){
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2640 pktl= s->packet_buffer;
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2641 *out= pktl->pkt;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2642
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2643 s->packet_buffer= pktl->next;
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2644 av_freep(&pktl);
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2645 return 1;
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2646 }else{
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2647 av_init_packet(out);
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2648 return 0;
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2649 }
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2650 }
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2651
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2652 /**
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2653 * Interleaves an AVPacket correctly so it can be muxed.
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2654 * @param out the interleaved packet will be output here
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2655 * @param in the input packet
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2656 * @param flush 1 if no further packets are available as input and all
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2657 * remaining packets should be output
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2658 * @return 1 if a packet was output, 0 if no packet could be output,
3175
55ce214a13ea typo: occured --> occurred
diego
parents: 3142
diff changeset
2659 * < 0 if an error occurred
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2660 */
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2661 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2662 if(s->oformat->interleave_packet)
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2663 return s->oformat->interleave_packet(s, out, in, flush);
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2664 else
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2665 return av_interleave_packet_per_dts(s, out, in, flush);
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2666 }
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2667
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2668 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2669 AVStream *st= s->streams[ pkt->stream_index];
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2670
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2671 //FIXME/XXX/HACK drop zero sized packets
820
feca73904e67 changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents: 819
diff changeset
2672 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2673 return 0;
717
a79f89d39c3c discard dummy packets before doing inapropriate checks on them and failing as a result
michael
parents: 708
diff changeset
2674
1443
404048ea11bc Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents: 1442
diff changeset
2675 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
1245
e59b75051ded dont be too picky about timestampsbeing wrong if the destination container is without timestamps and raw of the raw video / raw audio sort
michael
parents: 1244
diff changeset
2676 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
717
a79f89d39c3c discard dummy packets before doing inapropriate checks on them and failing as a result
michael
parents: 708
diff changeset
2677 return -1;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2678
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2679 if(pkt->dts == AV_NOPTS_VALUE)
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2680 return -1;
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2681
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2682 for(;;){
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2683 AVPacket opkt;
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2684 int ret= av_interleave_packet(s, &opkt, pkt, 0);
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2685 if(ret<=0) //FIXME cleanup needed for ret<0 ?
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2686 return ret;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2687
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2688 truncate_ts(s->streams[opkt.stream_index], &opkt);
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2689 ret= s->oformat->write_packet(s, &opkt);
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2690
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2691 av_free_packet(&opkt);
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2692 pkt= NULL;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2693
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2694 if(ret<0)
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2695 return ret;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
2696 if(url_ferror(s->pb))
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
2697 return url_ferror(s->pb);
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2698 }
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2699 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2700
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2701 int av_write_trailer(AVFormatContext *s)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2702 {
540
26a477a5ebda move free() of AVStream priv data to av_write_trailer()
michael
parents: 536
diff changeset
2703 int ret, i;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2704
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2705 for(;;){
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2706 AVPacket pkt;
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2707 ret= av_interleave_packet(s, &pkt, NULL, 1);
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2708 if(ret<0) //FIXME cleanup needed for ret<0 ?
540
26a477a5ebda move free() of AVStream priv data to av_write_trailer()
michael
parents: 536
diff changeset
2709 goto fail;
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2710 if(!ret)
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2711 break;
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2712
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2713 truncate_ts(s->streams[pkt.stream_index], &pkt);
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2714 ret= s->oformat->write_packet(s, &pkt);
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2715
536
76c47c58064f move packet interleaving function into AVOutputFormat, so it can be overriden easily instead of doing reordering twice if the muxer needs some other interleaving then dts based
michael
parents: 535
diff changeset
2716 av_free_packet(&pkt);
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2717
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2718 if(ret<0)
540
26a477a5ebda move free() of AVStream priv data to av_write_trailer()
michael
parents: 536
diff changeset
2719 goto fail;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
2720 if(url_ferror(s->pb))
554
e1f17fcfb92c write error handling
michael
parents: 547
diff changeset
2721 goto fail;
470
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2722 }
334e08488ad1 correctly interleave packets during encoding
michael
parents: 468
diff changeset
2723
869
8ff4e8ef8124 allow NULL write_header() and write_trailer()
michael
parents: 855
diff changeset
2724 if(s->oformat->write_trailer)
8ff4e8ef8124 allow NULL write_header() and write_trailer()
michael
parents: 855
diff changeset
2725 ret = s->oformat->write_trailer(s);
540
26a477a5ebda move free() of AVStream priv data to av_write_trailer()
michael
parents: 536
diff changeset
2726 fail:
554
e1f17fcfb92c write error handling
michael
parents: 547
diff changeset
2727 if(ret == 0)
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2734
diff changeset
2728 ret=url_ferror(s->pb);
540
26a477a5ebda move free() of AVStream priv data to av_write_trailer()
michael
parents: 536
diff changeset
2729 for(i=0;i<s->nb_streams;i++)
26a477a5ebda move free() of AVStream priv data to av_write_trailer()
michael
parents: 536
diff changeset
2730 av_freep(&s->streams[i]->priv_data);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2731 av_freep(&s->priv_data);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2732 return ret;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2733 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2734
2650
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2735 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2736 {
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2737 int i, j;
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2738 AVProgram *program=NULL;
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2739 void *tmp;
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2740
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2741 for(i=0; i<ac->nb_programs; i++){
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2742 if(ac->programs[i]->id != progid)
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2743 continue;
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2744 program = ac->programs[i];
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2745 for(j=0; j<program->nb_stream_indexes; j++)
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2746 if(program->stream_index[j] == idx)
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2747 return;
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2748
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2749 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2750 if(!tmp)
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2751 return;
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2752 program->stream_index = tmp;
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2753 program->stream_index[program->nb_stream_indexes++] = idx;
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2754 return;
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2755 }
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2756 }
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2757
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2758 /* "user interface" functions */
2658
8b0fbab56ea2 100l, fix dump_format, declare buf in dump_stream_format, sizeof(buf) is 4 because buf is char* since r10818
bcoudurier
parents: 2650
diff changeset
2759 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2649
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2760 {
2658
8b0fbab56ea2 100l, fix dump_format, declare buf in dump_stream_format, sizeof(buf) is 4 because buf is char* since r10818
bcoudurier
parents: 2650
diff changeset
2761 char buf[256];
2649
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2762 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2763 AVStream *st = ic->streams[i];
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2764 int g = ff_gcd(st->time_base.num, st->time_base.den);
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2765 avcodec_string(buf, sizeof(buf), st->codec, is_output);
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2766 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2767 /* the pid is an important information, so we display it */
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2768 /* XXX: add a generic system */
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2769 if (flags & AVFMT_SHOW_IDS)
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2770 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2771 if (strlen(st->language) > 0)
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2772 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2773 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2774 av_log(NULL, AV_LOG_INFO, ": %s", buf);
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2775 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2776 if(st->r_frame_rate.den && st->r_frame_rate.num)
2734
1b2658f20244 rename fps(frame per second) to tb(time base) to prevent
michael
parents: 2678
diff changeset
2777 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2649
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2778 /* else if(st->time_base.den && st->time_base.num)
2734
1b2658f20244 rename fps(frame per second) to tb(time base) to prevent
michael
parents: 2678
diff changeset
2779 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2649
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2780 else
2734
1b2658f20244 rename fps(frame per second) to tb(time base) to prevent
michael
parents: 2678
diff changeset
2781 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2649
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2782 }
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2783 av_log(NULL, AV_LOG_INFO, "\n");
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2784 }
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2785
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2786 void dump_format(AVFormatContext *ic,
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2787 int index,
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2788 const char *url,
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2789 int is_output)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2790 {
2672
8345d33e23b3 Remove unused variable, fixes warning:
diego
parents: 2666
diff changeset
2791 int i;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2792
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2793 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2794 is_output ? "Output" : "Input",
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2795 index,
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2796 is_output ? ic->oformat->name : ic->iformat->name,
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2797 is_output ? "to" : "from", url);
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2798 if (!is_output) {
776
47c7fa7c2e7c changing a few AV_LOG_DEBUG to AV_LOG_INFO
michael
parents: 775
diff changeset
2799 av_log(NULL, AV_LOG_INFO, " Duration: ");
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2800 if (ic->duration != AV_NOPTS_VALUE) {
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2801 int hours, mins, secs, us;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2802 secs = ic->duration / AV_TIME_BASE;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2803 us = ic->duration % AV_TIME_BASE;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2804 mins = secs / 60;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2805 secs %= 60;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2806 hours = mins / 60;
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2807 mins %= 60;
3230
ab26f1c6c5d3 Print duration with higher precision.
diego
parents: 3227
diff changeset
2808 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
ab26f1c6c5d3 Print duration with higher precision.
diego
parents: 3227
diff changeset
2809 (100 * us) / AV_TIME_BASE);
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2810 } else {
776
47c7fa7c2e7c changing a few AV_LOG_DEBUG to AV_LOG_INFO
michael
parents: 775
diff changeset
2811 av_log(NULL, AV_LOG_INFO, "N/A");
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2812 }
556
cb5f220888c0 print start_time patch by (Wolfram Gloger <wmglo at dent dot med dot uni-muenchen dot de>)
michael
parents: 555
diff changeset
2813 if (ic->start_time != AV_NOPTS_VALUE) {
cb5f220888c0 print start_time patch by (Wolfram Gloger <wmglo at dent dot med dot uni-muenchen dot de>)
michael
parents: 555
diff changeset
2814 int secs, us;
776
47c7fa7c2e7c changing a few AV_LOG_DEBUG to AV_LOG_INFO
michael
parents: 775
diff changeset
2815 av_log(NULL, AV_LOG_INFO, ", start: ");
556
cb5f220888c0 print start_time patch by (Wolfram Gloger <wmglo at dent dot med dot uni-muenchen dot de>)
michael
parents: 555
diff changeset
2816 secs = ic->start_time / AV_TIME_BASE;
cb5f220888c0 print start_time patch by (Wolfram Gloger <wmglo at dent dot med dot uni-muenchen dot de>)
michael
parents: 555
diff changeset
2817 us = ic->start_time % AV_TIME_BASE;
776
47c7fa7c2e7c changing a few AV_LOG_DEBUG to AV_LOG_INFO
michael
parents: 775
diff changeset
2818 av_log(NULL, AV_LOG_INFO, "%d.%06d",
556
cb5f220888c0 print start_time patch by (Wolfram Gloger <wmglo at dent dot med dot uni-muenchen dot de>)
michael
parents: 555
diff changeset
2819 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
cb5f220888c0 print start_time patch by (Wolfram Gloger <wmglo at dent dot med dot uni-muenchen dot de>)
michael
parents: 555
diff changeset
2820 }
776
47c7fa7c2e7c changing a few AV_LOG_DEBUG to AV_LOG_INFO
michael
parents: 775
diff changeset
2821 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2822 if (ic->bit_rate) {
776
47c7fa7c2e7c changing a few AV_LOG_DEBUG to AV_LOG_INFO
michael
parents: 775
diff changeset
2823 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2824 } else {
776
47c7fa7c2e7c changing a few AV_LOG_DEBUG to AV_LOG_INFO
michael
parents: 775
diff changeset
2825 av_log(NULL, AV_LOG_INFO, "N/A");
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2826 }
776
47c7fa7c2e7c changing a few AV_LOG_DEBUG to AV_LOG_INFO
michael
parents: 775
diff changeset
2827 av_log(NULL, AV_LOG_INFO, "\n");
192
0316a506aeb0 initial duration/start_time generic support - displays stream duration and average total bitrate when using an input file
bellard
parents: 175
diff changeset
2828 }
2650
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2829 if(ic->nb_programs) {
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2830 int j, k;
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2831 for(j=0; j<ic->nb_programs; j++) {
2678
e69fd694b767 print newline after program id even when the name is missing
nicodvb
parents: 2672
diff changeset
2832 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
e69fd694b767 print newline after program id even when the name is missing
nicodvb
parents: 2672
diff changeset
2833 ic->programs[j]->name ? ic->programs[j]->name : "");
2650
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2834 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2658
8b0fbab56ea2 100l, fix dump_format, declare buf in dump_stream_format, sizeof(buf) is 4 because buf is char* since r10818
bcoudurier
parents: 2650
diff changeset
2835 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2650
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2836 }
4e3d38c8896c API extension: AVProgram now has an array (stream_index) containing the indexes of the streams in AVFormatContext
nicodvb
parents: 2649
diff changeset
2837 } else
2649
1864b0a09d52 cosmetics: moved to a separate function the code to print the characteristics of an AVStream
nicodvb
parents: 2621
diff changeset
2838 for(i=0;i<ic->nb_streams;i++)
2658
8b0fbab56ea2 100l, fix dump_format, declare buf in dump_stream_format, sizeof(buf) is 4 because buf is char* since r10818
bcoudurier
parents: 2650
diff changeset
2839 dump_stream_format(ic, i, index, is_output);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2840 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2841
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2842 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2843 {
2163
6c0176688fae Move the video size and rate abbreviations system from libavformat to libavcodec
benoit
parents: 2160
diff changeset
2844 return av_parse_video_frame_size(width_ptr, height_ptr, str);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2845 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2846
2163
6c0176688fae Move the video size and rate abbreviations system from libavformat to libavcodec
benoit
parents: 2160
diff changeset
2847 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
168
808dabf5a88e * First round of AV sync fixes.
romansh
parents: 162
diff changeset
2848 {
2163
6c0176688fae Move the video size and rate abbreviations system from libavformat to libavcodec
benoit
parents: 2160
diff changeset
2849 AVRational frame_rate;
6c0176688fae Move the video size and rate abbreviations system from libavformat to libavcodec
benoit
parents: 2160
diff changeset
2850 int ret = av_parse_video_frame_rate(&frame_rate, arg);
6c0176688fae Move the video size and rate abbreviations system from libavformat to libavcodec
benoit
parents: 2160
diff changeset
2851 *frame_rate_num= frame_rate.num;
6c0176688fae Move the video size and rate abbreviations system from libavformat to libavcodec
benoit
parents: 2160
diff changeset
2852 *frame_rate_den= frame_rate.den;
6c0176688fae Move the video size and rate abbreviations system from libavformat to libavcodec
benoit
parents: 2160
diff changeset
2853 return ret;
168
808dabf5a88e * First round of AV sync fixes.
romansh
parents: 162
diff changeset
2854 }
808dabf5a88e * First round of AV sync fixes.
romansh
parents: 162
diff changeset
2855
2266
c3d2ed2063a0 Move av_gettime() back to lavf/utils.c
ramiro
parents: 2253
diff changeset
2856 /**
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
2857 * Gets the current time in microseconds.
2266
c3d2ed2063a0 Move av_gettime() back to lavf/utils.c
ramiro
parents: 2253
diff changeset
2858 */
c3d2ed2063a0 Move av_gettime() back to lavf/utils.c
ramiro
parents: 2253
diff changeset
2859 int64_t av_gettime(void)
c3d2ed2063a0 Move av_gettime() back to lavf/utils.c
ramiro
parents: 2253
diff changeset
2860 {
c3d2ed2063a0 Move av_gettime() back to lavf/utils.c
ramiro
parents: 2253
diff changeset
2861 struct timeval tv;
c3d2ed2063a0 Move av_gettime() back to lavf/utils.c
ramiro
parents: 2253
diff changeset
2862 gettimeofday(&tv,NULL);
c3d2ed2063a0 Move av_gettime() back to lavf/utils.c
ramiro
parents: 2253
diff changeset
2863 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
c3d2ed2063a0 Move av_gettime() back to lavf/utils.c
ramiro
parents: 2253
diff changeset
2864 }
c3d2ed2063a0 Move av_gettime() back to lavf/utils.c
ramiro
parents: 2253
diff changeset
2865
65
a58a8a53eb46 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 64
diff changeset
2866 int64_t parse_date(const char *datestr, int duration)
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2867 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2868 const char *p;
65
a58a8a53eb46 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 64
diff changeset
2869 int64_t t;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2870 struct tm dt;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2871 int i;
3769
93d4898d9b6e Mark several libavformat arrays const
reimar
parents: 3758
diff changeset
2872 static const char * const date_fmt[] = {
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2873 "%Y-%m-%d",
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2874 "%Y%m%d",
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2875 };
3769
93d4898d9b6e Mark several libavformat arrays const
reimar
parents: 3758
diff changeset
2876 static const char * const time_fmt[] = {
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2877 "%H:%M:%S",
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2878 "%H%M%S",
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2879 };
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2880 const char *q;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2881 int is_utc, len;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2882 char lastch;
477
3fc285cdb791 user specified start time offset
michael
parents: 470
diff changeset
2883 int negative = 0;
406
ea22a438ca79 fix obnoxious ogg_packet passing from encoder to muxer
michael
parents: 404
diff changeset
2884
ea22a438ca79 fix obnoxious ogg_packet passing from encoder to muxer
michael
parents: 404
diff changeset
2885 #undef time
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2886 time_t now = time(0);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2887
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2888 len = strlen(datestr);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2889 if (len > 0)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2890 lastch = datestr[len - 1];
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2891 else
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2892 lastch = '\0';
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2893 is_utc = (lastch == 'z' || lastch == 'Z');
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2894
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2895 memset(&dt, 0, sizeof(dt));
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2896
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2897 p = datestr;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2898 q = NULL;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2899 if (!duration) {
2557
0c4febec2258 Add explanatory comments to the parse_date function.
diego
parents: 2555
diff changeset
2900 /* parse the year-month-day part */
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2901 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
230
9f4f4ca9f7b5 simpler strptime - added os_support.[ch] - moved localtime_r to os_support.c
bellard
parents: 229
diff changeset
2902 q = small_strptime(p, date_fmt[i], &dt);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2903 if (q) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2904 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2905 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2906 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2907
2557
0c4febec2258 Add explanatory comments to the parse_date function.
diego
parents: 2555
diff changeset
2908 /* if the year-month-day part is missing, then take the
0c4febec2258 Add explanatory comments to the parse_date function.
diego
parents: 2555
diff changeset
2909 * current year-month-day time */
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2910 if (!q) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2911 if (is_utc) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2912 dt = *gmtime(&now);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2913 } else {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2914 dt = *localtime(&now);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2915 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2916 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2917 } else {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2918 p = q;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2919 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2920
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2921 if (*p == 'T' || *p == 't' || *p == ' ')
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2922 p++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2923
2557
0c4febec2258 Add explanatory comments to the parse_date function.
diego
parents: 2555
diff changeset
2924 /* parse the hour-minute-second part */
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2925 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
230
9f4f4ca9f7b5 simpler strptime - added os_support.[ch] - moved localtime_r to os_support.c
bellard
parents: 229
diff changeset
2926 q = small_strptime(p, time_fmt[i], &dt);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2927 if (q) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2928 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2929 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2930 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2931 } else {
2557
0c4febec2258 Add explanatory comments to the parse_date function.
diego
parents: 2555
diff changeset
2932 /* parse datestr as a duration */
887
d70e50f1495f COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 885
diff changeset
2933 if (p[0] == '-') {
d70e50f1495f COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 885
diff changeset
2934 negative = 1;
d70e50f1495f COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 885
diff changeset
2935 ++p;
d70e50f1495f COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 885
diff changeset
2936 }
2557
0c4febec2258 Add explanatory comments to the parse_date function.
diego
parents: 2555
diff changeset
2937 /* parse datestr as HH:MM:SS */
230
9f4f4ca9f7b5 simpler strptime - added os_support.[ch] - moved localtime_r to os_support.c
bellard
parents: 229
diff changeset
2938 q = small_strptime(p, time_fmt[0], &dt);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2939 if (!q) {
2557
0c4febec2258 Add explanatory comments to the parse_date function.
diego
parents: 2555
diff changeset
2940 /* parse datestr as S+ */
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2941 dt.tm_sec = strtol(p, (char **)&q, 10);
2559
c57d3d6c8f44 Make parse_date return INT64_MIN in case of unparsable input.
benoit
parents: 2557
diff changeset
2942 if (q == p)
c57d3d6c8f44 Make parse_date return INT64_MIN in case of unparsable input.
benoit
parents: 2557
diff changeset
2943 /* the parsing didn't succeed */
c57d3d6c8f44 Make parse_date return INT64_MIN in case of unparsable input.
benoit
parents: 2557
diff changeset
2944 return INT64_MIN;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2945 dt.tm_min = 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2946 dt.tm_hour = 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2947 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2948 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2949
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2950 /* Now we have all the fields that we can get */
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2951 if (!q) {
2559
c57d3d6c8f44 Make parse_date return INT64_MIN in case of unparsable input.
benoit
parents: 2557
diff changeset
2952 return INT64_MIN;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2953 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2954
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2955 if (duration) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2956 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2957 } else {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2958 dt.tm_isdst = -1; /* unknown */
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2959 if (is_utc) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2960 t = mktimegm(&dt);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2961 } else {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2962 t = mktime(&dt);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2963 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2964 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2965
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2966 t *= 1000000;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2967
2557
0c4febec2258 Add explanatory comments to the parse_date function.
diego
parents: 2555
diff changeset
2968 /* parse the .m... part */
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2969 if (*q == '.') {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2970 int val, n;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2971 q++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2972 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
2973 if (!isdigit(*q))
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2974 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2975 val += n * (*q - '0');
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2976 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2977 t += val;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2978 }
477
3fc285cdb791 user specified start time offset
michael
parents: 470
diff changeset
2979 return negative ? -t : t;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2980 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2981
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2982 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2983 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2984 const char *p;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2985 char tag[128], *q;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2986
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2987 p = info;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2988 if (*p == '?')
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2989 p++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2990 for(;;) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2991 q = tag;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2992 while (*p != '\0' && *p != '=' && *p != '&') {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2993 if ((q - tag) < sizeof(tag) - 1)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2994 *q++ = *p;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2995 p++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2996 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2997 *q = '\0';
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2998 q = arg;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
2999 if (*p == '=') {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3000 p++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3001 while (*p != '&' && *p != '\0') {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3002 if ((q - arg) < arg_size - 1) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3003 if (*p == '+')
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3004 *q++ = ' ';
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3005 else
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3006 *q++ = *p;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3007 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3008 p++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3009 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3010 *q = '\0';
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3011 }
885
da1d5db0ce5c COSMETICS: Remove all trailing whitespace.
diego
parents: 882
diff changeset
3012 if (!strcmp(tag, tag1))
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3013 return 1;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3014 if (*p != '&')
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3015 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3016 p++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3017 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3018 return 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3019 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3020
1291
185190bdc185 Clarified API for numbered sequences, patch by Michel Bardiaux % mbardiaux A mediaxim P be %
gpoirier
parents: 1285
diff changeset
3021 int av_get_frame_filename(char *buf, int buf_size,
185190bdc185 Clarified API for numbered sequences, patch by Michel Bardiaux % mbardiaux A mediaxim P be %
gpoirier
parents: 1285
diff changeset
3022 const char *path, int number)
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3023 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3024 const char *p;
290
7a3ed84008ec GCC 3.3.2 warnings patch by (Panagiotis Issaris <takis at lumumba dot luc dot ac dot be>)
michael
parents: 230
diff changeset
3025 char *q, buf1[20], c;
7a3ed84008ec GCC 3.3.2 warnings patch by (Panagiotis Issaris <takis at lumumba dot luc dot ac dot be>)
michael
parents: 230
diff changeset
3026 int nd, len, percentd_found;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3027
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3028 q = buf;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3029 p = path;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3030 percentd_found = 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3031 for(;;) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3032 c = *p++;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3033 if (c == '\0')
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3034 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3035 if (c == '%') {
9
97e61383cb81 * Extend the syntax of a filename for the img reader to allow looping. Thus
philipjsg
parents: 7
diff changeset
3036 do {
97e61383cb81 * Extend the syntax of a filename for the img reader to allow looping. Thus
philipjsg
parents: 7
diff changeset
3037 nd = 0;
97e61383cb81 * Extend the syntax of a filename for the img reader to allow looping. Thus
philipjsg
parents: 7
diff changeset
3038 while (isdigit(*p)) {
97e61383cb81 * Extend the syntax of a filename for the img reader to allow looping. Thus
philipjsg
parents: 7
diff changeset
3039 nd = nd * 10 + *p++ - '0';
97e61383cb81 * Extend the syntax of a filename for the img reader to allow looping. Thus
philipjsg
parents: 7
diff changeset
3040 }
97e61383cb81 * Extend the syntax of a filename for the img reader to allow looping. Thus
philipjsg
parents: 7
diff changeset
3041 c = *p++;
97e61383cb81 * Extend the syntax of a filename for the img reader to allow looping. Thus
philipjsg
parents: 7
diff changeset
3042 } while (isdigit(c));
97e61383cb81 * Extend the syntax of a filename for the img reader to allow looping. Thus
philipjsg
parents: 7
diff changeset
3043
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3044 switch(c) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3045 case '%':
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3046 goto addchar;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3047 case 'd':
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3048 if (percentd_found)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3049 goto fail;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3050 percentd_found = 1;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3051 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3052 len = strlen(buf1);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3053 if ((q - buf + len) > buf_size - 1)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3054 goto fail;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3055 memcpy(q, buf1, len);
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3056 q += len;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3057 break;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3058 default:
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3059 goto fail;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3060 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3061 } else {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3062 addchar:
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3063 if ((q - buf) < buf_size - 1)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3064 *q++ = c;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3065 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3066 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3067 if (!percentd_found)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3068 goto fail;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3069 *q = '\0';
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3070 return 0;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3071 fail:
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3072 *q = '\0';
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3073 return -1;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3074 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3075
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3076 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3077 {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3078 int len, i, j, c;
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3079 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3080
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3081 for(i=0;i<size;i+=16) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3082 len = size - i;
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3083 if (len > 16)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3084 len = 16;
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3085 PRINT("%08x ", i);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3086 for(j=0;j<16;j++) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3087 if (j < len)
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3088 PRINT(" %02x", buf[i+j]);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3089 else
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3090 PRINT(" ");
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3091 }
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3092 PRINT(" ");
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3093 for(j=0;j<len;j++) {
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3094 c = buf[i+j];
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3095 if (c < ' ' || c > '~')
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3096 c = '.';
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3097 PRINT("%c", c);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3098 }
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3099 PRINT("\n");
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3100 }
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3101 #undef PRINT
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3102 }
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3103
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3104 void av_hex_dump(FILE *f, uint8_t *buf, int size)
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3105 {
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3106 hex_dump_internal(NULL, f, 0, buf, size);
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3107 }
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3108
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3109 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3110 {
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3111 hex_dump_internal(avcl, NULL, level, buf, size);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3112 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3113
743
af4e24d6310c switch to native time bases
michael
parents: 737
diff changeset
3114 //FIXME needs to know the time_base
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3115 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3116 {
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3117 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3118 PRINT("stream #%d:\n", pkt->stream_index);
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3119 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3120 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3121 /* DTS is _always_ valid after av_read_frame() */
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3122 PRINT(" dts=");
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3123 if (pkt->dts == AV_NOPTS_VALUE)
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3124 PRINT("N/A");
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3125 else
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3126 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2936
86ab3f8db16c misc spelling/grammar fixes
diego
parents: 2932
diff changeset
3127 /* PTS may not be known if B-frames are present. */
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3128 PRINT(" pts=");
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3129 if (pkt->pts == AV_NOPTS_VALUE)
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3130 PRINT("N/A");
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3131 else
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3132 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3133 PRINT("\n");
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3134 PRINT(" size=%d\n", pkt->size);
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3135 #undef PRINT
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3136 if (dump_payload)
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3137 av_hex_dump(f, pkt->data, pkt->size);
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3138 }
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3139
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
3140 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
3141 {
1908
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3142 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3143 }
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3144
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3145 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3146 {
174083eafc6c Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents: 1906
diff changeset
3147 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
303
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
3148 }
2833c2311b66 initial av_read_frame() and av_seek_frame() support
bellard
parents: 293
diff changeset
3149
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3150 void url_split(char *proto, int proto_size,
511
056991ab9f10 HTTP Authentication Patch by (Petr Doubek <doubek at vision dot ee dot ethz dot ch>)
michael
parents: 502
diff changeset
3151 char *authorization, int authorization_size,
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3152 char *hostname, int hostname_size,
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3153 int *port_ptr,
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3154 char *path, int path_size,
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3155 const char *url)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3156 {
2868
22467d1cf49c Try to fix url_split() so that the ?foobar part is in the path and only the path.
michael
parents: 2861
diff changeset
3157 const char *p, *ls, *at, *col, *brk;
2581
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3158
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3159 if (port_ptr) *port_ptr = -1;
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3160 if (proto_size > 0) proto[0] = 0;
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3161 if (authorization_size > 0) authorization[0] = 0;
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3162 if (hostname_size > 0) hostname[0] = 0;
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3163 if (path_size > 0) path[0] = 0;
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3164
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3165 /* parse protocol */
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3166 if ((p = strchr(url, ':'))) {
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3167 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3168 p++; /* skip ':' */
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3169 if (*p == '/') p++;
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3170 if (*p == '/') p++;
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3171 } else {
2581
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3172 /* no protocol means plain filename */
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3173 av_strlcpy(path, url, path_size);
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3174 return;
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3175 }
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3176
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3177 /* separate path from hostname */
2868
22467d1cf49c Try to fix url_split() so that the ?foobar part is in the path and only the path.
michael
parents: 2861
diff changeset
3178 ls = strchr(p, '/');
22467d1cf49c Try to fix url_split() so that the ?foobar part is in the path and only the path.
michael
parents: 2861
diff changeset
3179 if(!ls)
22467d1cf49c Try to fix url_split() so that the ?foobar part is in the path and only the path.
michael
parents: 2861
diff changeset
3180 ls = strchr(p, '?');
22467d1cf49c Try to fix url_split() so that the ?foobar part is in the path and only the path.
michael
parents: 2861
diff changeset
3181 if(ls)
2869
michael
parents: 2868
diff changeset
3182 av_strlcpy(path, ls, path_size);
2868
22467d1cf49c Try to fix url_split() so that the ?foobar part is in the path and only the path.
michael
parents: 2861
diff changeset
3183 else
2581
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3184 ls = &p[strlen(p)]; // XXX
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3185
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3186 /* the rest is hostname, use that to parse auth/port */
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3187 if (ls != p) {
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3188 /* authorization (user[:pass]@hostname) */
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3189 if ((at = strchr(p, '@')) && at < ls) {
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3190 av_strlcpy(authorization, p,
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3191 FFMIN(authorization_size, at + 1 - p));
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3192 p = at + 1; /* skip '@' */
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3193 }
2581
d71f084d9835 refactor url_split(), preparing for IPv6 support
andoma
parents: 2573
diff changeset
3194
2583
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3195 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3196 /* [host]:port */
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3197 av_strlcpy(hostname, p + 1,
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3198 FFMIN(hostname_size, brk - p));
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3199 if (brk[1] == ':' && port_ptr)
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3200 *port_ptr = atoi(brk + 2);
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3201 } else if ((col = strchr(p, ':')) && col < ls) {
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3202 av_strlcpy(hostname, p,
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3203 FFMIN(col + 1 - p, hostname_size));
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3204 if (port_ptr) *port_ptr = atoi(col + 1);
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3205 } else
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3206 av_strlcpy(hostname, p,
26a6da30d5f1 Add IPv6 support to url_split()
andoma
parents: 2581
diff changeset
3207 FFMIN(ls + 1 - p, hostname_size));
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3208 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3209 }
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3210
462
b69898ffc92a move time_base (pts_num/pts_den) from AVFormatContext -> AVStream
michael
parents: 453
diff changeset
3211 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3212 int pts_num, int pts_den)
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3213 {
3581
3c57739a071d Remove common factors from timebase in av_set_pts_info().
michael
parents: 3575
diff changeset
3214 unsigned int gcd= ff_gcd(pts_num, pts_den);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3215 s->pts_wrap_bits = pts_wrap_bits;
3581
3c57739a071d Remove common factors from timebase in av_set_pts_info().
michael
parents: 3575
diff changeset
3216 s->time_base.num = pts_num/gcd;
3c57739a071d Remove common factors from timebase in av_set_pts_info().
michael
parents: 3575
diff changeset
3217 s->time_base.den = pts_den/gcd;
3c57739a071d Remove common factors from timebase in av_set_pts_info().
michael
parents: 3575
diff changeset
3218
3c57739a071d Remove common factors from timebase in av_set_pts_info().
michael
parents: 3575
diff changeset
3219 if(gcd>1)
3c57739a071d Remove common factors from timebase in av_set_pts_info().
michael
parents: 3575
diff changeset
3220 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);
0
05318cf2e886 renamed libav to libavformat
bellard
parents:
diff changeset
3221 }