JerryJeong/fmviewer3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
JerryJeong
2026-02-21 17:11:31 +09:00
commit 18b4338361
4001 changed files with 365464 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

883
project/fm_viewer/data/rm_format_avi.cpp Normal file
View File

@@ -0,0 +1,883 @@
#if (FILE_FORMAT_AVI)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if !defined(BBEXTRACT)
#include <QtCore>
#include "rm_constants.h"
#if (APPLICATION_PROFILE)
#include <QElapsedTimer>
#include <QDebug>
#endif
#endif //#if !defined(BBEXTRACT)
#include "rm_format_avi.h"
extern "C" {
#include "fileio.h"
}
// 참조: https://github.com/masayukig/jpegtoavi/blob/master/aviformat.txt
// http://telnet.or.kr/directx/htm/avirifffilereference.htm
// http://blog.naver.com/PostView.nhn?blogId=shlee7708&logNo=120121689464 <- 제일 편함!!
//static int skip_chunk(FILE *in)
//{
//char chunk_id[5];
//int chunk_size;
//int end_of_chunk;
// read_chars(_file,chunk_id,4);
// chunk_size=read_long(_file);
// printf("Uknown Chunk at %d\n",(int)ftell(_file));
// printf("-------------------------------\n");q
// printf(" chunk_id: %s\n",chunk_id);
// printf(" chunk_size: %d\n",chunk_size);
// printf("\n");
// end_of_chunk=ftell(_file)+chunk_size;
// if ((end_of_chunk%4)!=0)
// {
// end_of_chunk=end_of_chunk+(4-(end_of_chunk%4));
// }
// RMfseek(_file,end_of_chunk,SEEK_SET);
// return 0;
//}
//AVIRiff(RMfile in,bool durationOnly = false);
AVIRiff::AVIRiff(RMfile in,VideoReadMode mode, VideoPreInfo* info)
{
_readMode = mode;
_preInfo = info;
#if (SENSOR_AVI_SUBTITLE)
subtitles = NULL;
#endif
if(_preInfo != NULL) {
_preInfo->bDuration = false;
_preInfo->duration = 0;
#if (CHECK_VIDEO_BITRATE)
_preInfo->movSize = 0;
_preInfo->bMOVSize = false;
#endif
_preInfo->width = 0;
_preInfo->height = 0;
}
_isValid = false;
_file = in;
_videoStreamCount = 0;
#if (AVI_CHUNHO_SENSOR_FORMAT_1)
_gps_buffer = NULL;
_sensor_buffer = NULL;
_gps_buffer_size = 0;
_sensor_buffer_size = 0;
#endif
parse_riff();
}
AVIRiff::~AVIRiff()
{
for(int i=0;i<_videoStreamCount;i++)
{
if(_videoStreamFormat[i].palette != NULL)
{
free(_videoStreamFormat[i].palette);
}
}
#if (AVI_CHUNHO_SENSOR_FORMAT_1)
if(_gps_buffer != NULL)
{
free(_gps_buffer);
}
if(_sensor_buffer != NULL)
{
free(_sensor_buffer);
}
#endif
#if (SENSOR_AVI_SUBTITLE)
if(subtitles != NULL) {
for(int i=0;i<subtitles->size();i++) {
free(subtitles->at(i));
}
delete subtitles;
subtitles = NULL;
}
#endif
}
int AVIRiff::hex_dump_chunk(int chunk_len)
{
#if (USE_AVI_DUMP)
char chars[17];
int ch,n;
chars[16]=0;
int line = 0;
for (n=0; n<chunk_len; n++)
{
if ((n%16)==0)
{
if (n!=0)
{
printf("%s\n", chars);
}
printf("%04d ",line++);
memset(chars, ' ', 16);
}
ch=getc(_file);
if (ch==EOF)
{
break;
}
printf("%02x ", ch);
if (ch>=' ' && ch<=126)
{
chars[n%16]=ch;
}
else
{
chars[n%16]='.';
}
}
if ((n%16)!=0)
{
for (ch=n%16; ch<16; ch++)
{
printf(" ");
}
}
printf("%s\n", chars);
#else
#if !defined(BBEXTRACT)
Q_UNUSED(chunk_len);
#endif // #if !defined(BBEXTRACT)
#endif
return 0;
}
#if (DEBUG_AVI_FORMAT)
int AVIRiff::parse_idx1(int chunk_len)
{
index_entry_t index_entry;
int t;
printf(" IDX1\n");
printf(" -------------------------------\n");
printf(" ckid dwFlags dwChunkOffset dwChunkLength\n");
for (t=0; t<chunk_len/16; t++)
{
read_chars(_file,index_entry.ckid,4);
index_entry.dwFlags=read_long(_file);
index_entry.dwChunkOffset=read_long(_file);
index_entry.dwChunkLength=read_long(_file);
printf(" %s 0x%08x 0x%08x 0x%08x\n",
index_entry.ckid,
index_entry.dwFlags,
index_entry.dwChunkOffset,
index_entry.dwChunkLength);
}
printf("\n");
return 0;
}
#endif
int AVIRiff::read_avi_header() // ,struct avi_header_t *avi_header
{
// 연결되지 않은 영상 Bit rate : 121 kb/s
// 연결된 영상 Bit rate : 4 493 kb/s
//long offset=ftell(_file);
AVIHeader* avi_header = &_avi_header;
avi_header->TimeBetweenFrames=read_long(_file); // AVI TYPE 1 = 0
avi_header->MaximumDataRate=read_long(_file);
avi_header->PaddingGranularity=read_long(_file);
avi_header->Flags=read_long(_file);
avi_header->TotalNumberOfFrames=read_long(_file);
avi_header->NumberOfInitialFrames=read_long(_file);
avi_header->NumberOfStreams=read_long(_file);
avi_header->SuggestedBufferSize=read_long(_file);
avi_header->Width=read_long(_file);
avi_header->Height=read_long(_file);
avi_header->TimeScale=read_long(_file);
avi_header->DataRate=read_long(_file);
avi_header->StartTime=read_long(_file);
avi_header->DataLength=read_long(_file);
if(_preInfo != NULL)
{
_preInfo->width = avi_header->Width;
_preInfo->height = avi_header->Height;
}
#if (DEBUG_AVI_HEADER)
printf(" offset=0x%lx\n",offset);
printf(" TimeBetweenFrames: %d\n",avi_header->TimeBetweenFrames);
printf(" MaximumDataRate: %d\n",avi_header->MaximumDataRate);
printf(" PaddingGranularity: %d\n",avi_header->PaddingGranularity);
printf(" Flags: %d\n",avi_header->Flags);
printf(" TotalNumberOfFrames: %d\n",avi_header->TotalNumberOfFrames);
printf(" NumberOfInitialFrames: %d\n",avi_header->NumberOfInitialFrames);
printf(" NumberOfStreams: %d\n",avi_header->NumberOfStreams);
printf(" SuggestedBufferSize: %d\n",avi_header->SuggestedBufferSize);
printf(" Width: %d\n",avi_header->Width);
printf(" Height: %d\n",avi_header->Height);
printf(" TimeScale: %d\n",avi_header->TimeScale);
printf(" DataRate: %d\n",avi_header->DataRate);
printf(" StartTime: %d\n",avi_header->StartTime);
printf(" DataLength: %d\n",avi_header->DataLength);
fflush(stdout);
#endif
return 0;
}
void AVIRiff::print_data_handler(unsigned char *handler)
{
int t;
for (t=0; t<4; t++)
{
if ((handler[t]>='a' && handler[t]<='z') ||
(handler[t]>='A' && handler[t]<='Z') ||
(handler[t]>='0' && handler[t]<='9'))
{
printf("%c",handler[t]);
}
else
{
printf("[0x%02x]",handler[t]);
}
}
}
int AVIRiff::read_stream_header(stream_header_t *stream_header)
{
#if (DEBUG_AVI_STREAM_HEADER)
long offset=ftell(_file);
#endif
read_chars(_file,stream_header->DataType,4);
read_chars(_file,stream_header->DataHandler,4);
stream_header->Flags=read_long(_file);
stream_header->Priority=read_long(_file);
stream_header->InitialFrames=read_long(_file);
stream_header->TimeScale=read_long(_file);
stream_header->DataRate=read_long(_file);
stream_header->StartTime=read_long(_file);
stream_header->DataLength=read_long(_file);
stream_header->SuggestedBufferSize=read_long(_file);
stream_header->Quality=read_long(_file);
stream_header->SampleSize=read_long(_file);
if(_preInfo != NULL) {
if(_preInfo->duration == 0 && stream_header->TimeScale != 0)
{
_preInfo->bDuration = true;
_preInfo->duration = (unsigned int)(((double)(stream_header->TimeScale * 1000) / (double)stream_header->DataRate) * (double)stream_header->DataLength);
}
}
#if (DEBUG_AVI_STREAM_HEADER)
printf("------------------------------------------------------------\n");
printf(" offset=0x%lx\n",offset);
printf(" DataType: %s\n",stream_header->DataType);
printf(" DataHandler: ");
print_data_handler((unsigned char *)stream_header->DataHandler);
printf("\n");
printf(" Flags: %d\n",stream_header->Flags);
printf(" Priority: %d\n",stream_header->Priority);
printf(" InitialFrames: %d\n",stream_header->InitialFrames);
printf(" TimeScale: %d\n",stream_header->TimeScale);
printf(" DataRate: %d\n",stream_header->DataRate);
printf(" StartTime: %d\n",stream_header->StartTime);
printf(" DataLength: %d\n",stream_header->DataLength);
printf(" SuggestedBufferSize: %d\n",stream_header->SuggestedBufferSize);
printf(" Quality: %d\n",stream_header->Quality);
printf(" SampleSize: %d\n",stream_header->SampleSize);
fflush(stdout);
#endif
return 0;
}
int AVIRiff::read_stream_format(stream_format_t *stream_format)
{
int t,r,g,b;
#if (DEBUG_AVI_FORMAT)
long offset=ftell(_file);
#endif
stream_format->header_size=read_long(_file);
stream_format->image_width=read_long(_file);
stream_format->image_height=read_long(_file);
stream_format->number_of_planes=read_word(_file);
stream_format->bits_per_pixel=read_word(_file);
stream_format->compression_type=read_long(_file);
stream_format->image_size_in_bytes=read_long(_file);
stream_format->x_pels_per_meter=read_long(_file);
stream_format->y_pels_per_meter=read_long(_file);
stream_format->colors_used=read_long(_file);
stream_format->colors_important=read_long(_file);
stream_format->palette=0;
if (stream_format->colors_important!=0)
{
stream_format->palette= (int*) malloc(stream_format->colors_important*sizeof(int));
for (t=0; t<stream_format->colors_important; t++)
{
b=RMgetc(_file);
g=RMgetc(_file);
r=RMgetc(_file);
stream_format->palette[t]=(r<<16)+(g<<8)+b;
}
}
#if (DEBUG_AVI_FORMAT)
printf(" offset=0x%lx\n",offset);
printf(" header_size: %d\n",stream_format->header_size);
printf(" image_width: %d\n",stream_format->image_width);
printf(" image_height: %d\n",stream_format->image_height);
printf(" number_of_planes: %d\n",stream_format->number_of_planes);
printf(" bits_per_pixel: %d\n",stream_format->bits_per_pixel);
printf(" compression_type: %04x (%c%c%c%c)\n",stream_format->compression_type,
((stream_format->compression_type)&255),
((stream_format->compression_type>>8)&255),
((stream_format->compression_type>>16)&255),
((stream_format->compression_type>>24)&255));
printf(" image_size_in_bytes: %d\n",stream_format->image_size_in_bytes);
printf(" x_pels_per_meter: %d\n",stream_format->x_pels_per_meter);
printf(" y_pels_per_meter: %d\n",stream_format->y_pels_per_meter);
printf(" colors_used: %d\n",stream_format->colors_used);
printf(" colors_important: %d\n",stream_format->colors_important);
fflush(stdout);
#endif
return 0;
}
int AVIRiff::read_stream_format_auds(stream_format_auds_t *stream_format)
{
#if (DEBUG_AVI_FORMAT)
long offset=RMftell(_file);
#endif
stream_format->format=read_word(_file);
stream_format->channels=read_word(_file);
stream_format->samples_per_second=read_long(_file);
stream_format->bytes_per_second=read_long(_file);
#if (DEBUG_AVI_FORMAT)
int block_align=read_word(_file);
#endif
stream_format->block_size_of_data=read_word(_file);
stream_format->bits_per_sample=read_word(_file);
//stream_format->extended_size=read_word(_file);
#if (DEBUG_AVI_FORMAT)
printf(" offset=0x%lx\n",offset);
printf(" format: %d\n",stream_format->format);
printf(" channels: %d\n",stream_format->channels);
printf(" samples_per_second: %d\n",stream_format->samples_per_second);
printf(" bytes_per_second: %d\n",stream_format->bytes_per_second);
printf(" block_align: %d\n",block_align);
printf(" block_size_of_data: %d\n",stream_format->block_size_of_data);
printf(" bits_per_sample: %d\n",stream_format->bits_per_sample);
#endif
return 0;
}
int AVIRiff::parse_hdrl_list()
{
// stream_format_auds_t stream_format_auds;
// stream_header_t stream_header_auds;
char chunk_id[5];
int chunk_size;
char chunk_type[5];
int end_of_chunk;
int next_chunk;
//long offset=RMftell(_file);
AVI_STREAM_TYPE stream_type = UNDEFINED_STREAM;
read_chars(_file,chunk_id,4);
chunk_size=read_long(_file);
read_chars(_file,chunk_type,4);
#if (DEBUG_AVI_FORMAT)
printf(" AVI Header LIST (id=%s size=%d type=%s offset=0x%lx)\n",chunk_id,chunk_size,chunk_type,offset);
printf(" {\n");
#endif
end_of_chunk=RMftell(_file)+chunk_size-4;
if ((end_of_chunk%4)!=0)
{
//printf("Adjusting end of chunk %d\n", end_of_chunk);
//end_of_chunk=end_of_chunk+(4-(end_of_chunk%4));
//printf("Adjusting end of chunk %d\n", end_of_chunk);
}
if (strcmp(chunk_id,"JUNK")==0)
{
RMfseek(_file,end_of_chunk,SEEK_SET);
#if (DEBUG_AVI_FORMAT)
printf(" }\n");
#endif
return 0;
}
while (RMftell(_file)<end_of_chunk)
{
//long offset=RMftell(_file);
read_chars(_file,chunk_type,4);
chunk_size=read_long(_file);
next_chunk=RMftell(_file)+chunk_size;
if ((chunk_size%4)!=0)
{
//printf("Chunk size not a multiple of 4?\n");
//chunk_size=chunk_size+(4-(chunk_size%4));
}
#if (DEBUG_AVI_FORMAT)
printf(" %.4s (size=%d offset=0x%lx)\n",chunk_type,chunk_size,offset);
printf(" {\n");
#endif
if (strcasecmp("strh",chunk_type)==0)
{
long marker=RMftell(_file);
char buffer[5];
read_chars(_file,buffer,4);
RMfseek(_file,marker,SEEK_SET);
if (strcmp(buffer, "vids")==0)
{
stream_type = VIDEO_STREAM;
read_stream_header(&_videoStreamHeaders[_videoStreamCount]); // format 읽은후에 ++
}
else if (strcmp(buffer, "auds")==0)
{
stream_type = AUDIO_STREAM;
read_stream_header(&_audioStreamHeader);
}
else if (strcmp(buffer, "txts")==0)
{
stream_type = TXT_STREAM;
read_stream_header(&_txtStreamHeader);
}
else
{
#if (DEBUG_AVI_FORMAT)
printf("Unknown stream type %s\n", buffer);
#endif
return -1;
}
}
else if (strcasecmp("strf",chunk_type)==0)
{
if (stream_type == VIDEO_STREAM)
{
read_stream_format(&_videoStreamFormat[_videoStreamCount]);
_videoStreamCount++;
}
else if (stream_type==1)
{
read_stream_format_auds(&_audioStreamFormat);
}
else if (stream_type==2) // subtitle
{
// STRF 에는 아무 정보도 없음
//hex_dump_chunk(in,371);
//read_stream_format_auds(in,&stream_format_auds);
}
}
else if (strcasecmp("strd",chunk_type)==0)
{
//RMfseek(_file,offset,SEEK_SET);
//read_strd_format(chunk_size);
//_stopProcessing = true;
}
else
{
#if (DEBUG_AVI_FORMAT)
printf(" Unknown chunk type: %s\n",chunk_type);
#endif
// skip_chunk(_file);
}
#if (DEBUG_AVI_FORMAT)
printf(" }\n");
#endif
RMfseek(_file,next_chunk,SEEK_SET);
}
//printf("@@@@ %ld %d\n", RMftell(_file), end_of_chunk);
#if (DEBUG_AVI_FORMAT)
printf(" }\n");
#endif
RMfseek(_file,end_of_chunk,SEEK_SET);
return 0;
}
#if (SENSOR_AVI_SUBTITLE)
// 자막 데이터 AVI TYPE2
int AVIRiff::add_subtitle(long chunkSize)
{
if(subtitles == NULL) {
subtitles = new QList<char*>();
}
char* buffer = (char*)malloc(chunkSize + 1);
memset(buffer,0,chunkSize + 1);
RMfread(buffer,chunkSize,1,_file);
//qInfo() << buffer;
//QString str = QString(buffer);
subtitles->append(buffer);
//free(buffer);
return 0;
}
#endif
int AVIRiff::parse_movi_list(unsigned int size)
{
#if (APPLICATION_PROFILE)
QElapsedTimer timer;
timer.start();
#endif
char chunk_id[5] = {0,};
long chunk_size;
long end_of_chunk;
long offset=RMftell(_file);
#if (DEBUG_AVI_MOVI)
printf(" AVI MOVI Chunk (id=%s size=%d offset=0x%lx)\n",chunk_id,chunk_size,offset);
printf(" {\n");
fflush(stdout);
#endif
//int txtCount = 0;
while(RMftell(_file)< offset+(long)size-4)
{
read_chars(_file,chunk_id,4); // 4 byte
chunk_size=read_long(_file); // 4 byte
// pack 하지 않는다.. 다음 chunk 의 chunk_id + size 제외하고 이동
end_of_chunk= RMftell(_file) + chunk_size;
// H265 AVI 는 2 BYTE pack 되어 있음..
if ((end_of_chunk % 2) == 1)
{
end_of_chunk += 1;
}
if(chunk_id[2] == 't' && chunk_id[3] == 'x')
{
#if (SENSOR_AVI_SUBTITLE)
add_subtitle(chunk_size);
#endif
#if (DEBUG_AVI_MOVI)
printf(" MOVI TXT (id(%04d)=%s size=%d offset=%ld)\n",txtCount++,chunk_id,chunk_size,ftell(_file));
// hex_dump_chunk(chunk_size);
fflush(stdout);
#endif
}
else
{
// 이후 NAL SEI 처리 기능 추가
}
RMfseek(_file,end_of_chunk,SEEK_SET);
}
#if (DEBUG_AVI_MOVI)
printf(" }\n");
fflush(stdout);
#endif
#if (APPLICATION_PROFILE)
qInfo () << "Elapsed Time(parse_movi_list):" << timer.elapsed() << " msec" << " count:" << txtCount;
#endif
return 0;
}
//int AVIRiff::parse_hdrl(stream_format_t *stream_format, unsigned int size)
int AVIRiff::parse_hdrl(unsigned int size)
{
char chunk_id[5];
long chunk_size;
long end_of_chunk;
long offset=RMftell(_file);
read_chars(_file,chunk_id,4);
chunk_size=read_long(_file);
#if (DEBUG_AVI_FORMAT)
printf(" AVI Header Chunk (id=%s size=%d offset=0x%lx)\n",chunk_id,chunk_size,offset);
printf(" {\n");
#endif
end_of_chunk=RMftell(_file)+chunk_size;
if ((end_of_chunk%4)!=0) // 4BYTE PACK
{
end_of_chunk=end_of_chunk+(4-(end_of_chunk%4));
}
read_avi_header(); // 메인 헤더 읽기
#if (DEBUG_AVI_FORMAT)
printf(" }\n");
#endif
while(RMftell(_file)<offset+(long)size-4)
{
//printf("Should end at 0x%lx 0x%lx\n",offset+size,RMftell(_file));
parse_hdrl_list();
//parse_hdrl_list(stream_header,stream_format);
}
return 0;
}
int AVIRiff::parse_riff()
{
_isValid = false; // TAG 문제시만..
// 개별 chunk 처리
char chunk_id[5] = {0,};
int chunk_size;
char chunk_type[5] = {0,};
int end_of_chunk, end_of_subchunk;
//struct avi_header_t avi_header;
// stream_header_t stream_header;
// stream_format_t stream_format={0};
read_chars(_file,chunk_id,4);
chunk_size=read_long(_file);
read_chars(_file,chunk_type,4);
#if (DEBUG_AVI_FORMAT)
long offset=RMftell(_file);
printf("RIFF Chunk (id=%s size=%d type=%s offset=0x%lx)\n",chunk_id,chunk_size,chunk_type, offset);
printf("{\n");
#endif
if (strcasecmp("RIFF",chunk_id)!=0)
{
//printf("Not a RIFF file.\n");
return 1;
}
else if (strcasecmp("AVI ",chunk_type)!=0)
{
//printf("Not an AVI file.\n");
return 1;
}
end_of_chunk=RMftell(_file)+chunk_size-4;
#if (AVI_CHUNHO_SENSOR_FORMAT_1)
// Sensor 는 STRD 와 유사하게 end_of_chunk 뒤에 위치함
if(_preInfo == NULL)
{
RMfseek(_file,end_of_chunk,SEEK_SET);
bool b_gps_read = false;
bool b_sensor_read = false;
// 파일 끝까지 확인
int tryCount = 0;
while (RMfeof(_file) == 0 && tryCount++ < 100)
{
int offset = RMftell(_file);
#if !defined(BBEXTRACT)
QString offsetStr;
offsetStr.sprintf("%08X",offset);
#endif
read_chars(_file,chunk_id,4); // ID
chunk_size=read_long(_file); // 크기
// 센서 데이터 깨진 파일이 존재함 (chunck offset 이 짧거나..)
// qInfo() << "chunk_id:" << chunk_id << " chunk_size:" << chunk_size << " offset:" << offsetStr;
//end_of_subchunk=RMftell(_file)+chunk_size; // 범위 지정
//IDIT : 9355386 = 20
//gpsa : 9355398 = 4
//gps0 : 9357326 = 1920
//gsea : 9357354 = 20
//gsen : 9361576 = 4214
// 14 BYTE
if (strcasecmp("gps0",chunk_id)==0)
{
_gps_buffer_size = chunk_size;
_gps_buffer = (uint8_t*)malloc(chunk_size);
RMfread(_gps_buffer,_gps_buffer_size,1,_file);
b_gps_read = true;
}
else if (strcasecmp("gsen",chunk_id)==0)
{
if(chunk_size > 0) {
//qInfo() << "gsen offset:" << offsetStr;
_sensor_buffer_size = chunk_size;
_sensor_buffer = (uint8_t*)malloc(chunk_size);
RMfread(_sensor_buffer,_sensor_buffer_size,1,_file);
b_sensor_read = true;
}
}
// 깨진 데이터는 1 BYTE 씩 탐색
else if(chunk_size < 0 ||
(strcasecmp("IDIT",chunk_id) != 0 &&
strcasecmp("gpsa",chunk_id) != 0 &&
strcasecmp("gsea",chunk_id) != 0)) {
chunk_size = -7;
}
end_of_subchunk = offset + 8 + chunk_size;
if(b_sensor_read && b_gps_read)
{
break;
}
//qInfo() << chunk_id << ":" << end_of_subchunk << " =" << chunk_size;
RMfseek(_file,end_of_subchunk,SEEK_SET);
}
_isValid = true;
return 0;
}
#endif
while (RMftell(_file)<end_of_chunk)
{
read_chars(_file,chunk_id,4); // ID
chunk_size=read_long(_file); // 크기
end_of_subchunk=RMftell(_file)+chunk_size; // 범위 지정
if (strcasecmp("JUNK",chunk_id)==0 || strcasecmp("PAD ",chunk_id)==0) // ID 가 JUNK 또는 PAD 일 경우 ...
{
chunk_type[0]=0;
}
else
{
read_chars(_file,chunk_type,4); // 타입이 존재할 경우
}
#if (DEBUG_AVI_FORMAT)
long offset=RMftell(_file); // 현재 옵셋
printf(" New Chunk (id=%s size=%d type=%s offset=0x%lx)\n",chunk_id,chunk_size,chunk_type,offset);
printf(" {\n");
fflush(stdout);
#endif
if (strcasecmp("JUNK",chunk_id)==0 || strcasecmp("PAD ",chunk_id)==0) // 사용되지 않음
{
if ((chunk_size%4)!=0)
{
chunk_size=chunk_size+(4-(chunk_size%4));
}
#if (DEBUG_AVI_JUNK)
hex_dump_chunk(chunk_size);
#endif
}
else if (strcasecmp("INFO",chunk_type)==0) // 사용되지 않음..
{
if ((chunk_size%4)!=0)
{
chunk_size=chunk_size+(4-(chunk_size%4));
}
#if (DEBUG_AVI_INFO)
hex_dump_chunk(chunk_size);
#endif
}
else if (strcasecmp("hdrl",chunk_type)==0) // 헤더 리스트 처리
{
parse_hdrl(chunk_size);
// 기본 모드가 아닐 경우 종료 (subtitle 모델 체크는 subtitle 확인해야함)
// skip_chunk(_file);
}
else if (strcasecmp("movi",chunk_type)==0) // 'movi' 리스트 처리
{
#if (CHECK_VIDEO_BITRATE)
if(_readMode == AVIReadMOVSize && _preInfo != NULL) {
_preInfo->bMOVSize = true;
_preInfo->movSize = chunk_size;
}
#endif
// 처리할 필요 없음
#if (SENSOR_AVI_SUBTITLE)
if(_readMode == VideoReadSensor) {
parse_movi_list(chunk_size);
}
#endif
}
else if (strcasecmp("idx1",chunk_id)==0) // 인덱스 처리
{
RMfseek(_file,RMftell(_file)-4,SEEK_SET);
#if (DEBUG_AVI_FORMAT)
parse_idx1(chunk_size);
#endif
}
else
{
#if (DEBUG_AVI_FORMAT)
printf(" Unknown chunk at %d (%4s)\n",(int)RMftell(_file)-8,chunk_type);
#endif
if (chunk_size==0)
{
break;
}
}
// 필요한 정보 모두 수집되었는지 확인
if(_readMode == VideoReadDuration && _preInfo != NULL && _preInfo->bDuration == true) {
_isValid = true;
return 0;
}
#if (CHECK_VIDEO_BITRATE)
else if(_readMode == VideoReadMOVSize && _preInfo != NULL && _preInfo->bDuration == true && _preInfo->bMOVSize)
{
_isValid = true;
return 0;
}
#endif
RMfseek(_file,end_of_subchunk,SEEK_SET);
#if (DEBUG_AVI_FORMAT)
printf(" }\n");
#endif
}
#if (DEBUG_AVI_FORMAT)
printf("}\n");
#endif
_isValid = true;
return 0;
}
bool AVIRiff::duration(RMfile in, VideoPreInfo* info)
{
AVIRiff avi = AVIRiff(in,VideoReadDuration,info);
return avi.isValid();
}
#if (CHECK_VIDEO_BITRATE)
bool AVIRiff::movSize(RMfile in, VideoPreInfo* info)
{
AVIRiff avi = AVIRiff(in,VideoReadMOVSize,info);
return avi.isValid();
}
#endif
#endif // #if (FILE_FORMAT_AVI)