189 lines
7.4 KiB
C
189 lines
7.4 KiB
C
/***************************************************************************************
|
|
*
|
|
* IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
*
|
|
* By downloading, copying, installing or using the software you agree to this license.
|
|
* If you do not agree to this license, do not download, install,
|
|
* copy or use the software.
|
|
*
|
|
* Copyright (C) 2014-2024, Happytimesoft Corporation, all rights reserved.
|
|
*
|
|
* Redistribution and use in binary forms, with or without modification, are permitted.
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software distributed
|
|
* under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
|
|
* language governing permissions and limitations under the License.
|
|
*
|
|
****************************************************************************************/
|
|
|
|
#ifndef AVI_H
|
|
#define AVI_H
|
|
|
|
#include "format.h"
|
|
|
|
/* Flags in avih */
|
|
#define AVIF_HASINDEX 0x00000010 // Index at end of file?
|
|
#define AVIF_ISINTERLEAVED 0x00000100 // is interleaved?
|
|
#define AVIF_TRUSTCKTYPE 0x00000800 // Use CKType to find key frames?
|
|
|
|
#define AVIIF_KEYFRAME 0x00000010L // this frame is a key frame.
|
|
|
|
#pragma pack(push)
|
|
#pragma pack(1)
|
|
|
|
typedef struct avi_riff
|
|
{
|
|
uint32 riff;
|
|
uint32 len;
|
|
uint32 type;
|
|
} AVIRIFF;
|
|
|
|
typedef struct avi_pkt
|
|
{
|
|
uint32 type; // packet type : PACKET_TYPE_UNKNOW, PACKET_TYPE_VIDEO,PACKET_TYPE_AUDIO
|
|
uint8 * rbuf; // buffer pointer
|
|
uint32 mlen; // buffer size
|
|
uint8 * dbuf; // data pointer
|
|
uint32 len; // packet length
|
|
} AVIPKT;
|
|
|
|
typedef struct avi_main_header
|
|
{
|
|
uint32 dwMicroSecPerFrame; // render time for per frame, unit is ns
|
|
uint32 dwMaxBytesPerSec; // maximum data transfer rate
|
|
uint32 dwPaddingGranularity; // The length of the record block needs to be a multiple of this value, usually 2048
|
|
uint32 dwFlags; // Special attributes of AVI files, such as whether to include index blocks, whether audio and video data is interleaved
|
|
uint32 dwTotalFrames; // The total number of frames in the file
|
|
uint32 dwInitialFrames; // How much frames is needed before starting to play
|
|
uint32 dwStreams; // The number of data streams contained in the file
|
|
uint32 dwSuggestedBufferSize; // The recommended size of the buffer, usually the sum of the data needed to store an image and synchronize the sound
|
|
uint32 dwWidth; // Image width
|
|
uint32 dwHeight; // Image height
|
|
uint32 dwReserved[4]; // Reserved
|
|
} AVIMHDR;
|
|
|
|
typedef struct avi_stream_header
|
|
{
|
|
uint32 fccType; // 4 bytes, indicating the type of data stream, vids for video data stream, auds audio data stream
|
|
uint32 fccHandler; // 4 bytes, indicating the driver code for data stream decompression
|
|
uint32 dwFlags; // Data stream attribute
|
|
uint16 wPriority; // Play priority of this stream
|
|
uint16 wLanguage; // Audio language code
|
|
uint32 dwInitialFrames; // How much frames is needed before starting to play
|
|
uint32 dwScale; // The amount of data, the size of each video or the sample size of the audio
|
|
uint32 dwRate; // dwScale / dwRate = Number of samples per second
|
|
uint32 dwStart; // The location where the data stream starts playing, in dwScale
|
|
uint32 dwLength; // The amount of data in the data stream, in dwScale
|
|
uint32 dwSuggestedBufferSize; // Recommended buffer size
|
|
uint32 dwQuality; // Decompress quality parameters, the larger the value, the better the quality
|
|
uint32 dwSampleSize; // Sample size of the audio
|
|
|
|
struct
|
|
{
|
|
short left;
|
|
short top;
|
|
short right;
|
|
short bottom;
|
|
} rcFrame;
|
|
} AVISHDR;
|
|
|
|
typedef struct bitmap_info_header
|
|
{
|
|
uint32 biSize;
|
|
int biWidth;
|
|
int biHeight;
|
|
uint16 biPlanes;
|
|
uint16 biBitCount;
|
|
uint32 biCompression;
|
|
uint32 biSizeImage;
|
|
int biXPelsPerMeter;
|
|
int biYPelsPerMeter;
|
|
uint32 biClrUsed;
|
|
uint32 biClrImportant;
|
|
} BMPHDR;
|
|
|
|
typedef struct wave_format
|
|
{
|
|
uint16 wFormatTag; // format type
|
|
uint16 nChannels; // number of channels (i.e. mono, stereo...)
|
|
uint32 nSamplesPerSec; // sample rate
|
|
uint32 nAvgBytesPerSec; // for buffer estimation
|
|
uint16 nBlockAlign; // block size of data
|
|
uint16 wBitsPerSample; // number of bits per sample of mono data
|
|
uint16 cbSize; // the count in bytes of the size of
|
|
|
|
// extra information (after cbSize)
|
|
} WAVEFMT;
|
|
|
|
#pragma pack(pop)
|
|
|
|
typedef struct avi_file_context
|
|
{
|
|
uint32 ctxf_read : 1; // Read mode
|
|
uint32 ctxf_write : 1; // Write mode
|
|
uint32 ctxf_idx : 1; // File has index
|
|
uint32 ctxf_audio : 1; // Has audio stream
|
|
uint32 ctxf_video : 1; // Has video stream
|
|
uint32 ctxf_idx_m : 1; // Index data write mode: = 1, memory mode; = 0, temporary file
|
|
uint32 ctxf_calcfps: 1; // Calc video framerate
|
|
uint32 ctxf_nalu : 1; // For H.26x, VPS, SPS,PPS written flag
|
|
uint32 ctxf_iframe : 1; // For H.26x, key frame written flag
|
|
uint32 ctxf_res : 23;
|
|
|
|
AVIMHDR avi_hdr; // AVI main header
|
|
AVISHDR str_v; // Video stream header
|
|
BMPHDR bmp; // BITMAP format
|
|
AVISHDR str_a; // Audio stream header
|
|
WAVEFMT wave; // WAVE format
|
|
|
|
FILE * fp; // Read and write file handle
|
|
uint32 flen; // Total file length, used when reading
|
|
char filename[256]; // File full path
|
|
void * mutex; // Write, close mutex
|
|
|
|
uint32 v_fps; // Video frame rate
|
|
char v_fcc[4]; // Video compression standard, "H264","H265","JPEG","MP4V"
|
|
int v_width; // Video width
|
|
int v_height; // Video height
|
|
uint8 * v_extra; // Video extra data
|
|
int v_extra_len; // Video extra data length
|
|
|
|
int a_rate; // Sampling frequency
|
|
uint16 a_fmt; // Audio compression standard
|
|
int a_chns; // Number of audio channels
|
|
uint8 * a_extra; // Audio extra data
|
|
int a_extra_len; // Audio extra data length
|
|
|
|
int i_movi; // Where the real data starts
|
|
int i_movi_end; // End of data, where the index starts
|
|
int i_riff; // After the index, the length of the entire file
|
|
|
|
int pkt_offset; // Packet offset when reading
|
|
int index_offset; // Index position when reading
|
|
int back_index; // The first read index position when reading in reverse order, usually sps/vps
|
|
|
|
int i_frame_video; // Video frame read and write count
|
|
int i_frame_audio; // Audio frame read and write count
|
|
uint32 audio_total_bytes; // Audio total bytes
|
|
|
|
uint32 prev_ts; // previous timestamp
|
|
uint32 v_s_time; // Video start recording time = first packet write time
|
|
uint32 v_e_time; // The time when video package was recently written
|
|
uint32 a_s_time; // Audio start recording time = first packet write time
|
|
uint32 a_e_time; // The time when audio package was recently written
|
|
|
|
int i_idx_max; // The maximum number of indexes currently allocated
|
|
int i_idx; // Current index number (video index + audio index)
|
|
int * idx; // Index array
|
|
|
|
FILE * idx_fp; // Index temporary file
|
|
int idx_fix[128]; // Index file data is enough to write once for one sector
|
|
int idx_fix_off; // The index data has been stored in the offset of idx_fix
|
|
} AVICTX;
|
|
|
|
#endif // AVI_H
|
|
|
|
|
|
|