64 return FFMPEG_CONFIGURATION;
69 #define LICENSE_PREFIX "libavformat license: "
73 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
91 timestamp < st->pts_wrap_reference)
103 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
107 if (st->codec->codec)
108 return st->codec->codec;
110 switch(st->codec->codec_type){
112 if(s->video_codec)
return s->video_codec;
115 if(s->audio_codec)
return s->audio_codec;
118 if(s->subtitle_codec)
return s->subtitle_codec;
131 #define SANE_CHUNK_SIZE (50000000)
137 if(remaining < size){
140 s->
maxsize= newsize - !newsize;
142 remaining=
FFMAX(remaining, 0);
145 if(s->
maxsize>=0 && remaining+1 < size){
159 int64_t orig_pos = pkt->
pos;
160 int orig_size = pkt->
size;
164 int prev_size = pkt->
size;
184 if (ret != read_size) {
197 return pkt->
size > orig_size ? pkt->
size - orig_size :
ret;
228 int score, nodat = 0, score_max=0;
232 lpd.
buf = zerobuffer;
257 if (score > score_max) {
260 }
else if (score == score_max)
265 *score_ret= score_max;
274 if(score_ret > *score_max){
275 *score_max= score_ret;
288 static const struct {
309 for (i = 0; fmt_id_type[i].name; i++) {
310 if (!strcmp(fmt->
name, fmt_id_type[i].name)) {
340 const char *filename,
void *logctx,
341 unsigned int offset,
unsigned int max_probe_size)
343 AVProbeData pd = { filename ? filename :
"", NULL, -offset };
344 unsigned char *
buf = NULL;
346 int ret = 0, probe_size, buf_offset = 0;
349 if (!max_probe_size) {
355 "Specified probe size value %u cannot be < %u\n", max_probe_size,
PROBE_BUF_MIN);
359 if (offset >= max_probe_size) {
371 probe_size =
FFMIN(probe_size<<1,
FFMAX(max_probe_size, probe_size+1))) {
378 if ((ret =
avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
388 if (buf_offset < offset)
399 av_log(logctx,
AV_LOG_WARNING,
"Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
401 av_log(logctx,
AV_LOG_DEBUG,
"Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
413 return ret < 0 ? ret : score;
417 const char *filename,
void *logctx,
418 unsigned int offset,
unsigned int max_probe_size)
421 return ret < 0 ? ret : 0;
438 "will be ignored with AVFMT_NOFILE format.\n");
461 (*plast_pktl)->next = pktl;
463 *packet_buffer = pktl;
497 av_log(NULL,
AV_LOG_ERROR,
"Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
509 if ((ret =
init_input(s, filename, &tmp)) < 0)
547 if (id3v2_extra_meta) {
611 "Failed to reallocate probe buffer for stream %d\n",
677 if (!pktl || ret ==
AVERROR(EAGAIN))
693 "Dropped corrupted packet (stream = %d)\n",
728 #if FF_API_READ_PACKET
814 if (frame_size <= 0 || st->codec->sample_rate <= 0)
845 #if CONFIG_H264_DECODER
882 if (!first_program) {
907 program = first_program;
962 pts_buffer[0]= pktl->
pkt.
pts;
963 for(i=0; i<delay && pts_buffer[i] > pts_buffer[i+1]; i++)
964 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i+1]);
966 pktl->
pkt.
dts= pts_buffer[0];
999 av_log(s,
AV_LOG_DEBUG,
"first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1033 int num, den, presentation_delayed, delay, i;
1049 presentation_delayed = 0;
1055 presentation_delayed = 1;
1071 if(strcmp(s->
iformat->
name,
"mov,mp4,m4a,3gp,3g2,mj2"))
1118 presentation_delayed = 1;
1120 av_dlog(NULL,
"IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1125 if (presentation_delayed) {
1175 av_dlog(NULL,
"OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1189 *pkt_buf = pktl->
next;
1193 *pkt_buf_end = NULL;
1207 int ret = 0, got_output = 0;
1218 while (size > 0 || (pkt == &
flush_pkt && got_output)) {
1223 &out_pkt.
data, &out_pkt.
size, data, size,
1232 got_output = !!out_pkt.
size;
1282 #if FF_API_DESTRUCT_PACKET
1284 out_pkt.destruct = pkt->destruct;
1285 pkt->destruct = NULL;
1319 *pkt_buffer = pktl->
next;
1321 *pkt_buffer_end = NULL;
1328 int ret = 0, i, got_packet = 0;
1356 cur_pkt.
pts < cur_pkt.
dts) {
1364 av_log(s,
AV_LOG_DEBUG,
"ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1376 "%s, packets or times may be invalid.\n",
1421 av_log(s,
AV_LOG_DEBUG,
"read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1458 int64_t last_dts = next_pkt->
dts;
1467 last_dts = pktl->
pkt.
dts;
1494 if (pktl && ret !=
AVERROR(EAGAIN)) {
1546 int first_audio_index = -1;
1559 first_audio_index = i;
1561 return first_audio_index >= 0 ? first_audio_index : 0;
1621 int *nb_index_entries,
1622 unsigned int *index_entries_allocated_size,
1628 if((
unsigned)*nb_index_entries + 1 >= UINT_MAX /
sizeof(
AVIndexEntry))
1634 if (size < 0 || size > 0x3FFFFFFF)
1641 index_entries_allocated_size,
1642 (*nb_index_entries + 1) *
1647 *index_entries= entries;
1652 index= (*nb_index_entries)++;
1653 ie= &entries[
index];
1654 av_assert0(index==0 || ie[-1].timestamp < timestamp);
1656 ie= &entries[
index];
1660 memmove(entries + index + 1, entries + index,
sizeof(
AVIndexEntry)*(*nb_index_entries - index));
1661 (*nb_index_entries)++;
1662 }
else if(ie->
pos == pos && distance < ie->min_distance)
1681 timestamp, size, distance, flags);
1685 int64_t wanted_timestamp,
int flags)
1694 if(b && entries[b-1].timestamp < wanted_timestamp)
1700 if(timestamp >= wanted_timestamp)
1702 if(timestamp <= wanted_timestamp)
1722 wanted_timestamp, flags);
1726 int64_t (*read_timestamp)(
struct AVFormatContext *,
int , int64_t *, int64_t ))
1728 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1729 if (stream_index >= 0)
1738 int64_t ts_min, ts_max, ts;
1743 if (stream_index < 0)
1757 index=
FFMAX(index, 0);
1763 av_dlog(s,
"using cached pos_min=0x%"PRIx64
" dts_min=%s\n",
1777 av_dlog(s,
"using cached pos_max=0x%"PRIx64
" pos_limit=0x%"PRIx64
" dts_max=%s\n",
1782 pos=
ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->
read_timestamp);
1797 int64_t (*read_timestamp)(
struct AVFormatContext *,
int , int64_t *, int64_t ))
1800 int64_t limit, ts_max;
1802 int64_t pos_max = filesize - 1;
1805 pos_max =
FFMAX(0, (pos_max) - step);
1813 int64_t tmp_pos = pos_max + 1;
1814 int64_t tmp_ts =
ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1820 if(tmp_pos >= filesize)
1833 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1834 int64_t ts_min, int64_t ts_max,
int flags, int64_t *ts_ret,
1835 int64_t (*read_timestamp)(
struct AVFormatContext *,
int , int64_t *, int64_t ))
1846 ts_min =
ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1851 if(ts_min >= target_ts){
1857 if ((ret =
ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1862 if(ts_max <= target_ts){
1867 if(ts_min > ts_max){
1869 }
else if(ts_min == ts_max){
1874 while (pos_min < pos_limit) {
1875 av_dlog(s,
"pos_min=0x%"PRIx64
" pos_max=0x%"PRIx64
" dts_min=%s dts_max=%s\n",
1877 assert(pos_limit <= pos_max);
1880 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1882 pos =
av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1883 + pos_min - approximate_keyframe_distance;
1884 }
else if(no_change==1){
1886 pos = (pos_min + pos_limit)>>1;
1894 else if(pos > pos_limit)
1903 av_dlog(s,
"%"PRId64
" %"PRId64
" %"PRId64
" / %s %s %s target:%s limit:%"PRId64
" start:%"PRId64
" noc:%d\n",
1904 pos_min, pos, pos_max,
1906 pos_limit, start_pos, no_change);
1912 if (target_ts <= ts) {
1913 pos_limit = start_pos - 1;
1917 if (target_ts >= ts) {
1927 ts_min =
ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1929 ts_max =
ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1930 av_dlog(s,
"pos=0x%"PRIx64
" %s<=%s<=%s\n",
1938 int64_t pos_min, pos_max;
1943 if (pos < pos_min) pos= pos_min;
1944 else if(pos > pos_max) pos= pos_max;
1954 int stream_index, int64_t timestamp,
int flags)
1961 st = s->
streams[stream_index];
1965 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1968 if(index < 0 || index==st->nb_index_entries-1){
1986 }
while (read_status ==
AVERROR(EAGAIN));
1987 if (read_status < 0)
1994 av_log(s,
AV_LOG_ERROR,
"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
2018 int64_t timestamp,
int flags)
2030 if(stream_index < 0){
2032 if(stream_index < 0)
2066 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2072 flags & ~AVSEEK_FLAG_BACKWARD);
2085 if(min_ts > ts || max_ts < ts)
2087 if (stream_index < -1 || stream_index >= (
int)s->
nb_streams)
2098 if (stream_index == -1 && s->
nb_streams == 1) {
2105 time_base.
num * (int64_t)AV_TIME_BASE,
2125 if (ret<0 && ts != min_ts && max_ts != ts) {
2126 ret =
av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2166 int64_t
start_time, start_time1, start_time_text, end_time, end_time1;
2167 int64_t
duration, duration1, filesize;
2172 start_time = INT64_MAX;
2173 start_time_text = INT64_MAX;
2174 end_time = INT64_MIN;
2175 duration = INT64_MIN;
2181 if (start_time1 < start_time_text)
2182 start_time_text = start_time1;
2184 start_time =
FFMIN(start_time, start_time1);
2187 end_time1 = start_time1
2189 end_time =
FFMAX(end_time, end_time1);
2200 duration =
FFMAX(duration, duration1);
2203 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text <
AV_TIME_BASE))
2204 start_time = start_time_text;
2205 else if(start_time > start_time_text)
2208 if (start_time != INT64_MAX) {
2210 if (end_time != INT64_MIN) {
2218 duration =
FFMAX(duration, end_time - start_time);
2226 double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2228 if (bitrate >= 0 && bitrate <= INT_MAX)
2253 int i, show_warning = 0;
2292 #define DURATION_MAX_READ_SIZE 250000LL
2293 #define DURATION_MAX_RETRY 4
2300 int read_size, i,
ret;
2336 }
while(ret ==
AVERROR(EAGAIN));
2339 read_size += pkt->
size;
2344 duration = end_time = pkt->
pts;
2382 file_size =
FFMAX(0, file_size);
2408 av_dlog(ic,
"%d: start_time: %0.3f duration: %0.3f\n", i,
2412 av_dlog(ic,
"stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2423 #define FAIL(errmsg) do { \
2425 *errmsg_ptr = errmsg; \
2432 FAIL(
"unspecified frame size");
2434 FAIL(
"unspecified sample format");
2436 FAIL(
"unspecified sample rate");
2438 FAIL(
"unspecified number of channels");
2440 FAIL(
"no decodable DTS frames");
2444 FAIL(
"unspecified size");
2446 FAIL(
"unspecified pixel format");
2449 FAIL(
"no frame in rv30/40 and no sar");
2453 FAIL(
"unspecified size");
2460 FAIL(
"unknown codec");
2468 int got_picture = 1,
ret = 0;
2489 av_dict_set(options ? options : &thread_opt,
"threads",
"1", 0);
2506 while ((pkt.
size > 0 || (!pkt.
data && got_picture)) &&
2516 &got_picture, &pkt);
2523 &got_picture, &pkt);
2538 if(!pkt.
data && !got_picture)
2560 if(tag == tags[i].tag)
2581 if (sflags & (1 << (bps - 1))) {
2613 for(i=0; tags && tags[i]; i++){
2616 if (codec_tags->
id ==
id) {
2617 *tag = codec_tags->
tag;
2629 for(i=0; tags && tags[i]; i++){
2650 if (j != i && next_start > ch->
start && next_start < end)
2653 ch->
end = (end == INT64_MAX) ? ch->
start : end;
2658 if(i<60*12)
return (i+1)*1001;
2659 else return ((
const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2683 #if FF_API_FORMAT_PARAMETERS
2746 "%s, packets or times may be invalid.\n",
2754 av_dict_set(options ? &options[i] : &thread_opt,
"threads",
"1", 0);
2773 #if FF_API_R_FRAME_RATE
2791 int fps_analyze_framecount = 20;
2800 fps_analyze_framecount *= 2;
2804 fps_analyze_framecount = 0;
2838 "Stream #%d: not enough frames to estimate rate; "
2839 "consider increasing probesize\n", i);
2861 goto find_stream_info_err;
2864 goto find_stream_info_err;
2869 read_size += pkt->
size;
2876 "packet %d with DTS %"PRId64
", packet %d with DTS "
2889 "packet %d with DTS %"PRId64
", packet %d with DTS "
2925 #if FF_API_R_FRAME_RATE
2930 && pkt->
dts - (uint64_t)last < INT64_MAX){
2943 double sdts= dts*framerate/(1001*12);
2945 int64_t ticks=
llrint(sdts+j*0.5);
2946 double error= sdts - ticks + j*0.5;
2978 try_decode_frame(ic, st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2997 (options && i < orig_nb_streams) ?
2998 &options[i] : NULL);
3003 "decoding for stream %d failed\n", st->
index);
3026 double best_error = 0.01;
3042 if (error < best_error) {
3044 best_fps = std_fps.
num;
3049 best_fps, 12*1001, INT_MAX);
3060 double best_error= 0.01;
3074 if(error < best_error && best_error> 0.000000001){
3128 "Could not find codec parameters for stream %d (%s): %s\n"
3129 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3138 find_stream_info_err:
3171 int wanted_stream_nb,
3178 unsigned *program = NULL;
3181 if (related_stream >= 0 && wanted_stream_nb < 0) {
3188 for (i = 0; i < nb_streams; i++) {
3189 int real_stream_index = program ? program[i] : i;
3194 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3209 if ((best_multiframe > multiframe) ||
3210 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3211 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >=
count))
3214 best_bitrate = bitrate;
3215 best_multiframe = multiframe;
3216 ret = real_stream_index;
3218 if (program && i == nb_streams - 1 && ret < 0) {
3225 *decoder_ret = best_decoder;
3302 #if FF_API_CLOSE_INPUT_FILE
3338 #if FF_API_NEW_STREAM
3354 if (s->
nb_streams >= INT_MAX/
sizeof(*streams))
3397 #if FF_API_R_FRAME_RATE
3412 av_dlog(ac,
"new_program: id=0x%04x\n",
id);
3501 if(strcmp(
"language", tag->
key)){
3502 const char *p = tag->
value;
3506 size_t len = strcspn(p,
"\x8\xa\xb\xc\xd");
3547 display_aspect_ratio.
num, display_aspect_ratio.
den);
3552 #if FF_API_R_FRAME_RATE
3596 is_output ?
"Output" :
"Input",
3599 is_output ?
"to" :
"from", url);
3604 int hours, mins, secs, us;
3642 int j, k, total = 0;
3647 name ? name->
value :
"");
3655 if (total < ic->nb_streams)
3671 const char *path,
int number)
3674 char *q, buf1[20],
c;
3675 int nd,
len, percentd_found;
3688 nd = nd * 10 + *p++ -
'0';
3700 snprintf(buf1,
sizeof(buf1),
"%0*d", nd, number);
3702 if ((q - buf + len) > buf_size - 1)
3704 memcpy(q, buf1, len);
3712 if ((q - buf) < buf_size - 1)
3716 if (!percentd_found)
3729 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3731 for(i=0;i<
size;i+=16) {
3738 PRINT(
" %02x", buf[i+j]);
3743 for(j=0;j<
len;j++) {
3745 if (c < ' ' || c >
'~')
3766 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3801 char *authorization,
int authorization_size,
3802 char *hostname,
int hostname_size,
3804 char *path,
int path_size,
3807 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3809 if (port_ptr) *port_ptr = -1;
3810 if (proto_size > 0) proto[0] = 0;
3811 if (authorization_size > 0) authorization[0] = 0;
3812 if (hostname_size > 0) hostname[0] = 0;
3813 if (path_size > 0) path[0] = 0;
3816 if ((p = strchr(url,
':'))) {
3828 ls = strchr(p,
'/');
3829 ls2 = strchr(p,
'?');
3833 ls =
FFMIN(ls, ls2);
3843 while ((at = strchr(p,
'@')) && at < ls) {
3845 FFMIN(authorization_size, at + 1 - at2));
3849 if (*p ==
'[' && (brk = strchr(p,
']')) && brk < ls) {
3852 FFMIN(hostname_size, brk - p));
3853 if (brk[1] ==
':' && port_ptr)
3854 *port_ptr = atoi(brk + 2);
3855 }
else if ((col = strchr(p,
':')) && col < ls) {
3857 FFMIN(col + 1 - p, hostname_size));
3858 if (port_ptr) *port_ptr = atoi(col + 1);
3861 FFMIN(ls + 1 - p, hostname_size));
3868 static const char hex_table_uc[16] = {
'0',
'1',
'2',
'3',
3871 'C',
'D',
'E',
'F' };
3872 static const char hex_table_lc[16] = {
'0',
'1',
'2',
'3',
3875 'c',
'd',
'e',
'f' };
3876 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3878 for(i = 0; i <
s; i++) {
3879 buff[i * 2] = hex_table[src[i] >> 4];
3880 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3897 if (c >=
'0' && c <=
'9')
3899 else if (c >=
'A' && c <=
'F')
3914 #if FF_API_SET_PTS_INFO
3915 void av_set_pts_info(
AVStream *s,
int pts_wrap_bits,
3916 unsigned int pts_num,
unsigned int pts_den)
3923 unsigned int pts_num,
unsigned int pts_den)
3927 if(new_tb.
num != pts_num)
3932 if(new_tb.
num <= 0 || new_tb.
den <= 0) {
3944 const char *ptr = str;
3949 char *dest = NULL, *dest_end;
3950 int key_len, dest_len = 0;
3953 while (*ptr && (
av_isspace(*ptr) || *ptr ==
','))
3960 if (!(ptr = strchr(key,
'=')))
3963 key_len = ptr - key;
3965 callback_get_buf(context, key, key_len, &dest, &dest_len);
3966 dest_end = dest + dest_len - 1;
3970 while (*ptr && *ptr !=
'\"') {
3974 if (dest && dest < dest_end)
3978 if (dest && dest < dest_end)
3986 for (; *ptr && !(
av_isspace(*ptr) || *ptr ==
','); ptr++)
3987 if (dest && dest < dest_end)
4007 struct tm time1 = {0}, time2 = {0};
4021 return ofmt->
query_codec(codec_id, std_compliance);
4065 if (channel_layout) {
4073 if (width || height) {
4080 bytestream_put_le32(&data, flags);
4082 bytestream_put_le32(&data, channels);
4084 bytestream_put_le64(&data, channel_layout);
4086 bytestream_put_le32(&data, sample_rate);
4087 if (width || height) {
4088 bytestream_put_le32(&data, width);
4089 bytestream_put_le32(&data, height);
4101 av_reduce(&stream_sample_aspect_ratio.
num, &stream_sample_aspect_ratio.
den,
4102 stream_sample_aspect_ratio.
num, stream_sample_aspect_ratio.
den, INT_MAX);
4103 if (stream_sample_aspect_ratio.
num <= 0 || stream_sample_aspect_ratio.
den <= 0)
4104 stream_sample_aspect_ratio = undef;
4106 av_reduce(&frame_sample_aspect_ratio.
num, &frame_sample_aspect_ratio.
den,
4107 frame_sample_aspect_ratio.
num, frame_sample_aspect_ratio.
den, INT_MAX);
4108 if (frame_sample_aspect_ratio.
num <= 0 || frame_sample_aspect_ratio.
den <= 0)
4109 frame_sample_aspect_ratio = undef;
4111 if (stream_sample_aspect_ratio.
num)
4112 return stream_sample_aspect_ratio;
4114 return frame_sample_aspect_ratio;
4136 if (*spec <= '9' && *spec >=
'0')
4137 return strtol(spec, NULL, 0) == st->
index;
4138 else if (*spec ==
'v' || *spec ==
'a' || *spec ==
's' || *spec ==
'd' ||
4152 if (*spec++ ==
':') {
4153 int i,
index = strtol(spec, NULL, 0);
4156 return i == st->
index;
4160 }
else if (*spec ==
'p' && *(spec + 1) ==
':') {
4164 prog_id = strtol(spec, &endptr, 0);
4169 if (*endptr++ ==
':') {
4170 int stream_idx = strtol(endptr, NULL, 0);
4171 return stream_idx >= 0 &&
4181 }
else if (*spec ==
'#') {
4184 sid = strtol(spec + 1, &endptr, 0);
4186 return st->
id == sid;
4196 static const uint8_t avci100_1080p_extradata[] = {
4198 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4199 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4200 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4201 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4202 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4203 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4204 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4205 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4206 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4208 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4211 static const uint8_t avci100_1080i_extradata[] = {
4213 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4214 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4215 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4216 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4217 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4218 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4219 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4220 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4221 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4222 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4223 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4225 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4228 static const uint8_t avci50_1080i_extradata[] = {
4230 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4231 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4232 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4233 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4234 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4235 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4236 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4237 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4238 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4239 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4240 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4242 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4245 static const uint8_t avci100_720p_extradata[] = {
4247 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4248 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4249 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4250 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4251 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4252 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4253 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4254 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4255 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4256 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4258 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4265 data = avci100_1080p_extradata;
4266 size =
sizeof(avci100_1080p_extradata);
4268 data = avci100_1080i_extradata;
4269 size =
sizeof(avci100_1080i_extradata);
4272 data = avci50_1080i_extradata;
4273 size =
sizeof(avci50_1080i_extradata);
4275 data = avci100_720p_extradata;
4276 size =
sizeof(avci100_720p_extradata);