~ubuntu-branches/ubuntu/oneiric/libav/oneiric

//av_log(s, AV_LOG_DEBUG, "dts:%"PRId64" offset:%"PRId64" %d/%d smpl_siz:%d base:%d st:%d size:%d\n", pkt->dts, ast->frame_offset, ast->scale, ast->rate, ast->sample_size, AV_TIME_BASE, avi->stream_index, size);

798

pkt->stream_index = avi->stream_index;

799

800

if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {

801

AVIndexEntry *e;

802

int index;

803

assert(st->index_entries);

804

805

index= av_index_search_timestamp(st, ast->frame_offset, 0);

806

e= &st->index_entries[index];

807

808

if(index >= 0 && e->timestamp == ast->frame_offset){

809

if (e->flags & AVINDEX_KEYFRAME)

810

pkt->flags |= AV_PKT_FLAG_KEY;

811

}

812

} else {

813

pkt->flags |= AV_PKT_FLAG_KEY;

814

}

815

if(ast->sample_size)

816

ast->frame_offset += pkt->size;

817

else

818

ast->frame_offset++;

819

}

820

ast->remaining -= size;

821

if(!ast->remaining){

822

avi->stream_index= -1;

823

ast->packet_size= 0;

824

}

825

826

return size;

827

}

828

829

memset(d, -1, sizeof(int)*8);

830

for(i=sync=url_ftell(pb); !url_feof(pb); i++) {

831

int j;

832

833

for(j=0; j<7; j++)

834

d[j]= d[j+1];

835

d[7]= get_byte(pb);

836

837

size= d[4] + (d[5]<<8) + (d[6]<<16) + (d[7]<<24);

838

839

n= get_stream_idx(d+2);

840

//av_log(s, AV_LOG_DEBUG, "%X %X %X %X %X %X %X %X %"PRId64" %d %d\n", d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n);

841

if(i + (uint64_t)size > avi->fsize || d[0]<0)

842

continue;

843

844

//parse ix##

845

if( (d[0] == 'i' && d[1] == 'x' && n < s->nb_streams)

846

//parse JUNK

847

||(d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K')

848

||(d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1')){

849

url_fskip(pb, size);

850

//av_log(s, AV_LOG_DEBUG, "SKIP\n");

851

goto resync;

852

}

853

854

//parse stray LIST

855

if(d[0] == 'L' && d[1] == 'I' && d[2] == 'S' && d[3] == 'T'){

856

url_fskip(pb, 4);

857

goto resync;

858

}

859

860

n= get_stream_idx(d);

861

862

if(!((i-avi->last_pkt_pos)&1) && get_stream_idx(d+1) < s->nb_streams)

863

continue;

864

865

//detect ##ix chunk and skip

866

if(d[2] == 'i' && d[3] == 'x' && n < s->nb_streams){

867

url_fskip(pb, size);

868

goto resync;

869

}

870

871

//parse ##dc/##wb

872

if(n < s->nb_streams){

873

AVStream *st;

874

AVIStream *ast;

875

st = s->streams[n];

876

ast = st->priv_data;

877

878

if(s->nb_streams>=2){

879

AVStream *st1 = s->streams[1];

880

AVIStream *ast1= st1->priv_data;

881

//workaround for broken small-file-bug402.avi

882

if( d[2] == 'w' && d[3] == 'b'

883

&& n==0

884

&& st ->codec->codec_type == AVMEDIA_TYPE_VIDEO

885

&& st1->codec->codec_type == AVMEDIA_TYPE_AUDIO

886

&& ast->prefix == 'd'*256+'c'

887

&& (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)

888

){

889

n=1;

890

st = st1;

891

ast = ast1;

892

av_log(s, AV_LOG_WARNING, "Invalid stream + prefix combination, assuming audio.\n");

893

}

894

}

895

896

897

if( (st->discard >= AVDISCARD_DEFAULT && size==0)

898

/*|| (st->discard >= AVDISCARD_NONKEY && !(pkt->flags & AV_PKT_FLAG_KEY))*/ //FIXME needs a little reordering

899

|| st->discard >= AVDISCARD_ALL){

900

if(ast->sample_size) ast->frame_offset += size;

901

else ast->frame_offset++;

902

url_fskip(pb, size);

903

goto resync;

904

}

905

906

if (d[2] == 'p' && d[3] == 'c' && size<=4*256+4) {

907

int k = get_byte(pb);

908

int last = (k + get_byte(pb) - 1) & 0xFF;

909

910

get_le16(pb); //flags

911

912

for (; k <= last; k++)

913

ast->pal[k] = get_be32(pb)>>8;// b + (g << 8) + (r << 16);

914

ast->has_pal= 1;

915

goto resync;

916

} else if( ((ast->prefix_count<5 || sync+9 > i) && d[2]<128 && d[3]<128) ||

917

d[2]*256+d[3] == ast->prefix /*||

918

(d[2] == 'd' && d[3] == 'c') ||

919

(d[2] == 'w' && d[3] == 'b')*/) {

920

921

//av_log(s, AV_LOG_DEBUG, "OK\n");

922

if(d[2]*256+d[3] == ast->prefix)

923

ast->prefix_count++;

924

else{

925

ast->prefix= d[2]*256+d[3];

926

ast->prefix_count= 0;

927

}

928

929

avi->stream_index= n;

930

ast->packet_size= size + 8;

931

ast->remaining= size;

932

933

if(size || !ast->sample_size){

934

uint64_t pos= url_ftell(pb) - 8;

935

if(!st->index_entries || !st->nb_index_entries || st->index_entries[st->nb_index_entries - 1].pos < pos){

936

av_add_index_entry(st, pos, ast->frame_offset, size, 0, AVINDEX_KEYFRAME);

937

}

938

}

939

goto resync;

940

}

941

}

942

}

943

944

return AVERROR_EOF;

945

}

946

947

/* XXX: We make the implicit supposition that the positions are sorted

948

for each stream. */

949

static int avi_read_idx1(AVFormatContext *s, int size)

950

{

951

AVIContext *avi = s->priv_data;

952

ByteIOContext *pb = s->pb;

953

int nb_index_entries, i;

954

AVStream *st;

955

AVIStream *ast;

956

unsigned int index, tag, flags, pos, len;

957

unsigned last_pos= -1;

958

959

nb_index_entries = size / 16;

960

if (nb_index_entries <= 0)

961

return -1;

962

963

/* Read the entries and sort them in each stream component. */

964

for(i = 0; i < nb_index_entries; i++) {

965

tag = get_le32(pb);

966

flags = get_le32(pb);

967

pos = get_le32(pb);

968

len = get_le32(pb);

969

#if defined(DEBUG_SEEK)

970

av_log(s, AV_LOG_DEBUG, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/",

971

i, tag, flags, pos, len);

972

#endif

973

if(i==0 && pos > avi->movi_list)

974

avi->movi_list= 0; //FIXME better check

975

pos += avi->movi_list;

976

977

index = ((tag & 0xff) - '0') * 10;

978

index += ((tag >> 8) & 0xff) - '0';

979

if (index >= s->nb_streams)

980

continue;

981

st = s->streams[index];

982

ast = st->priv_data;

983

984

#if defined(DEBUG_SEEK)

985

av_log(s, AV_LOG_DEBUG, "%d cum_len=%"PRId64"\n", len, ast->cum_len);

986

#endif

987

if(url_feof(pb))

988

return -1;

989

990

if(last_pos == pos)

991

avi->non_interleaved= 1;

992

else if(len || !ast->sample_size)

993

av_add_index_entry(st, pos, ast->cum_len, len, 0, (flags&AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);

994

if(ast->sample_size)

995

ast->cum_len += len;

996

else

997

ast->cum_len ++;

998

last_pos= pos;

999

}

1000

return 0;

1001

}

1002

1003

static int guess_ni_flag(AVFormatContext *s){

1004

int i;

1005

int64_t last_start=0;

1006

int64_t first_end= INT64_MAX;

1007

int64_t oldpos= url_ftell(s->pb);

1008

1009

for(i=0; i<s->nb_streams; i++){

1010

AVStream *st = s->streams[i];

1011

int n= st->nb_index_entries;

1012

unsigned int size;

1013

1014

if(n <= 0)

1015

continue;

1016

1017

if(n >= 2){

1018

int64_t pos= st->index_entries[0].pos;

1019

url_fseek(s->pb, pos + 4, SEEK_SET);

1020

size= get_le32(s->pb);

1021

if(pos + size > st->index_entries[1].pos)

1022

last_start= INT64_MAX;

1023

}

1024

1025

if(st->index_entries[0].pos > last_start)

1026

last_start= st->index_entries[0].pos;

1027

if(st->index_entries[n-1].pos < first_end)

1028

first_end= st->index_entries[n-1].pos;

1029

}

1030

url_fseek(s->pb, oldpos, SEEK_SET);

1031

return last_start > first_end;

1032

}

1033

1034

static int avi_load_index(AVFormatContext *s)

1035

{

1036

AVIContext *avi = s->priv_data;

1037

ByteIOContext *pb = s->pb;

1038

uint32_t tag, size;

1039

int64_t pos= url_ftell(pb);

1040

int ret = -1;

1041

1042

if (url_fseek(pb, avi->movi_end, SEEK_SET) < 0)

1043

goto the_end; // maybe truncated file

1044

#ifdef DEBUG_SEEK

1045

printf("movi_end=0x%"PRIx64"\n", avi->movi_end);

1046

#endif

1047

for(;;) {

1048

if (url_feof(pb))

1049

break;

1050

tag = get_le32(pb);

1051

size = get_le32(pb);

1052

#ifdef DEBUG_SEEK

1053

printf("tag=%c%c%c%c size=0x%x\n",

1054

tag & 0xff,

1055

(tag >> 8) & 0xff,

1056

(tag >> 16) & 0xff,

1057

(tag >> 24) & 0xff,

1058

size);

1059

#endif

1060

switch(tag) {

1061

case MKTAG('i', 'd', 'x', '1'):

1062

if (avi_read_idx1(s, size) < 0)

1063

goto skip;

1064

ret = 0;

1065

goto the_end;

1066

break;

1067

default:

1068

skip:

1069

size += (size & 1);

1070

if (url_fseek(pb, size, SEEK_CUR) < 0)

1071

goto the_end; // something is wrong here

1072

break;

1073

}

1074

}

1075

the_end:

1076

url_fseek(pb, pos, SEEK_SET);

1077

return ret;

1078

}

1079

1080

static int avi_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)

1081

{

1082

AVIContext *avi = s->priv_data;

1083

AVStream *st;

1084

int i, index;

1085

int64_t pos;

1086

AVIStream *ast;

1087

1088

if (!avi->index_loaded) {

1089

/* we only load the index on demand */

1090

avi_load_index(s);

1091

avi->index_loaded = 1;

1092

}

1093

assert(stream_index>= 0);

1094

1095

st = s->streams[stream_index];

1096

ast= st->priv_data;

1097

index= av_index_search_timestamp(st, timestamp * FFMAX(ast->sample_size, 1), flags);

1098

if(index<0)

1099

return -1;

1100

1101

/* find the position */

1102

pos = st->index_entries[index].pos;

1103

timestamp = st->index_entries[index].timestamp / FFMAX(ast->sample_size, 1);

1104

1105

// av_log(s, AV_LOG_DEBUG, "XX %"PRId64" %d %"PRId64"\n", timestamp, index, st->index_entries[index].timestamp);

1106

1107

if (CONFIG_DV_DEMUXER && avi->dv_demux) {

1108

/* One and only one real stream for DV in AVI, and it has video */

1109

/* offsets. Calling with other stream indexes should have failed */

1110

/* the av_index_search_timestamp call above. */

1111

assert(stream_index == 0);

1112

1113

/* Feed the DV video stream version of the timestamp to the */

1114

/* DV demux so it can synthesize correct timestamps. */

1115

dv_offset_reset(avi->dv_demux, timestamp);

1116

1117

url_fseek(s->pb, pos, SEEK_SET);

1118

avi->stream_index= -1;

1119

return 0;

1120

}

1121

1122

for(i = 0; i < s->nb_streams; i++) {

1123

AVStream *st2 = s->streams[i];

1124

AVIStream *ast2 = st2->priv_data;

1125

1126

ast2->packet_size=

1127

ast2->remaining= 0;

1128

1129

if (st2->nb_index_entries <= 0)

1130

continue;

1131

1132

// assert(st2->codec->block_align);

1133

assert((int64_t)st2->time_base.num*ast2->rate == (int64_t)st2->time_base.den*ast2->scale);

1134

index = av_index_search_timestamp(

1135

st2,

1136

av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),

1137

flags | AVSEEK_FLAG_BACKWARD);

1138

if(index<0)

1139

index=0;

1140

1141

if(!avi->non_interleaved){

1142

while(index>0 && st2->index_entries[index].pos > pos)

1143

index--;

1144

while(index+1 < st2->nb_index_entries && st2->index_entries[index].pos < pos)

1145

index++;

1146

}

1147

1148

// av_log(s, AV_LOG_DEBUG, "%"PRId64" %d %"PRId64"\n", timestamp, index, st2->index_entries[index].timestamp);

1149

/* extract the current frame number */

1150

ast2->frame_offset = st2->index_entries[index].timestamp;

1151

}

1152

1153

/* do the seek */

1154

url_fseek(s->pb, pos, SEEK_SET);

1155

avi->stream_index= -1;

1156

return 0;

1157

}

1158

1159

static int avi_read_close(AVFormatContext *s)

1160

{

1161

int i;

1162

AVIContext *avi = s->priv_data;

1163

1164

for(i=0;i<s->nb_streams;i++) {

1165

AVStream *st = s->streams[i];

1166

av_free(st->codec->palctrl);

1167

}

1168

1169

if (avi->dv_demux)

1170

av_free(avi->dv_demux);

1171

1172

return 0;

1173

}

1174

1175

static int avi_probe(AVProbeData *p)

1176

{

1177

int i;

1178

1179

/* check file header */

1180

for(i=0; avi_headers[i][0]; i++)

1181

if(!memcmp(p->buf , avi_headers[i] , 4) &&

1182

!memcmp(p->buf+8, avi_headers[i]+4, 4))

1183

return AVPROBE_SCORE_MAX;

1184

1185

return 0;

1186

}

1187

1188

AVInputFormat avi_demuxer = {

1189

"avi",

1190

NULL_IF_CONFIG_SMALL("AVI format"),

1191

sizeof(AVIContext),

1192

avi_probe,

1193

avi_read_header,

1194

avi_read_packet,

1195

avi_read_close,

1196

avi_read_seek,

1197

.metadata_conv = ff_avi_metadata_conv,

1198

};

Older »