| 1 |
#include "FFReadStream.h" |
| 2 |
#include "FFReadHandler.h" |
| 3 |
#include "avm_fourcc.h" |
| 4 |
#include "avm_output.h" |
| 5 |
#include "utils.h" |
| 6 |
|
| 7 |
#include "avm_avformat.h" |
| 8 |
#include "avm_avcodec.h" |
| 9 |
|
| 10 |
#include <stdio.h> |
| 11 |
#include <stdlib.h> |
| 12 |
#include <string.h> |
| 13 |
|
| 14 |
AVM_BEGIN_NAMESPACE; |
| 15 |
|
| 16 |
static int get_fcc(enum AVCodecID id) |
| 17 |
{ |
| 18 |
const struct id2fcc { |
| 19 |
enum AVCodecID id; |
| 20 |
uint32_t fcc; |
| 21 |
} id2fcct[] = { |
| 22 |
{ AV_CODEC_ID_MPEG1VIDEO, RIFFINFO_MPG1 }, |
| 23 |
{ AV_CODEC_ID_MPEG1VIDEO, mmioFOURCC('P', 'I', 'M', '1') }, |
| 24 |
{ AV_CODEC_ID_MPEG2VIDEO, RIFFINFO_MPG2 }, |
| 25 |
{ AV_CODEC_ID_H263, mmioFOURCC('H', '2', '6', '3') }, |
| 26 |
{ AV_CODEC_ID_H263P, mmioFOURCC('H', '2', '6', '3') }, |
| 27 |
{ AV_CODEC_ID_H263I, mmioFOURCC('I', '2', '6', '3') }, |
| 28 |
{ AV_CODEC_ID_H264, mmioFOURCC('H', '2', '6', '4') }, |
| 29 |
{ AV_CODEC_ID_MSMPEG4V3, mmioFOURCC('D', 'I', 'V', '3') }, |
| 30 |
{ AV_CODEC_ID_MPEG4, mmioFOURCC('D', 'I', 'V', 'X') }, |
| 31 |
{ AV_CODEC_ID_MSMPEG4V2, mmioFOURCC('M', 'P', '4', '2') }, |
| 32 |
{ AV_CODEC_ID_FLV1, mmioFOURCC('F', 'L', 'V', '1') }, |
| 33 |
{ AV_CODEC_ID_MJPEG, mmioFOURCC('M', 'J', 'P', 'G') }, |
| 34 |
{ AV_CODEC_ID_DTS, 0x10 }, |
| 35 |
{ AV_CODEC_ID_MP2, 0x50 }, |
| 36 |
{ AV_CODEC_ID_MP3, 0x55 }, |
| 37 |
{ AV_CODEC_ID_AC3, WAVE_FORMAT_DVM }, |
| 38 |
{ AV_CODEC_ID_AAC, 'M' | ('P' << 8) }, // MP4A |
| 39 |
{ AV_CODEC_ID_DVVIDEO, mmioFOURCC('D', 'V', 'S', 'D') }, |
| 40 |
{ AV_CODEC_ID_DVAUDIO, ('D' << 8) | 'A' }, |
| 41 |
{ AV_CODEC_ID_NONE } |
| 42 |
}; |
| 43 |
//printf("TRANSLATE %d 0x%x\n", id, id); |
| 44 |
for (const struct id2fcc* p = id2fcct; p->id; p++) |
| 45 |
if (p->id == id) |
| 46 |
return p->fcc; |
| 47 |
//printf("FAILED\n"); |
| 48 |
return 0; |
| 49 |
} |
| 50 |
|
| 51 |
FFReadStream::FFReadStream(FFReadHandler* handler, uint_t sid, AVStream* avs) |
| 52 |
: m_pHandler(handler), m_pAvStream(avs), m_pAvContext(0), m_uiSId(sid), |
| 53 |
m_Packets(5000), m_uiPosition(0), m_dTimestamp(0.), |
| 54 |
m_uiKeyChunks(0), m_uiKeySize(0), m_uiKeyMaxSize(0), m_uiKeyMinSize(0), |
| 55 |
m_uiDeltaSize(0), m_uiDeltaMaxSize(0), m_uiDeltaMinSize(0) |
| 56 |
{ |
| 57 |
m_StartTime = (m_pHandler->m_pContext->start_time != (int64_t)AV_NOPTS_VALUE) |
| 58 |
? m_pHandler->m_pContext->start_time : 0; |
| 59 |
m_dLength = (double)m_pHandler->m_pContext->duration / (double)AV_TIME_BASE; |
| 60 |
|
| 61 |
AVM_WRITE("FF stream", "Starttime:%" PRId64 " Duration:%fs\n", m_StartTime, m_dLength); |
| 62 |
//printf("codec %d %.4s\n", avs->codec->codec_id, &avs->codec->codec_tag); |
| 63 |
//printf("CODECRA %d %d %d\n", avs->codec->frame_rate, avs->codec->frame_rate_base, avs->r_frame_rate_base); |
| 64 |
if (0 && avs->codecpar->codec_id == AV_CODEC_ID_MPEG1VIDEO) |
| 65 |
{ |
| 66 |
m_pAvContext = avcodec_alloc_context3(NULL); |
| 67 |
//AVCodec* codec = avcodec_find_encoder(avs->codec->codec_id); |
| 68 |
if (m_pAvContext) |
| 69 |
{ |
| 70 |
const AVCodec* codec = avcodec_find_decoder(avs->codecpar->codec_id); |
| 71 |
if (codec && avcodec_open2(m_pAvContext, codec, NULL) == 0) |
| 72 |
{ |
| 73 |
m_pAvContext->flags |= AV_CODEC_FLAG_TRUNCATED; |
| 74 |
m_pAvContext->skip_frame = AVDISCARD_NONKEY; |
| 75 |
//printf("Opened hurryup decoder %p %p\n", codec, m_pAvContext->codec->decode); |
| 76 |
} |
| 77 |
else |
| 78 |
{ |
| 79 |
avcodec_close(m_pAvContext); |
| 80 |
m_pAvContext = 0; |
| 81 |
} |
| 82 |
} |
| 83 |
} |
| 84 |
} |
| 85 |
|
| 86 |
FFReadStream::~FFReadStream() |
| 87 |
{ |
| 88 |
if (m_pAvContext) |
| 89 |
{ |
| 90 |
avcodec_close(m_pAvContext); |
| 91 |
free(m_pAvContext); |
| 92 |
} |
| 93 |
} |
| 94 |
|
| 95 |
double FFReadStream::CacheSize() const |
| 96 |
{ |
| 97 |
return 1.; //(double)m_Packets.size() / (double)m_Packets.capacity() + 0.2; |
| 98 |
} |
| 99 |
|
| 100 |
void FFReadStream::ClearCache() |
| 101 |
{ |
| 102 |
} |
| 103 |
|
| 104 |
size_t FFReadStream::GetHeader(void* header, size_t size) const |
| 105 |
{ |
| 106 |
return 0; |
| 107 |
} |
| 108 |
|
| 109 |
framepos_t FFReadStream::GetPrevKeyFrame(framepos_t frame) const |
| 110 |
{ |
| 111 |
return ERR; |
| 112 |
} |
| 113 |
|
| 114 |
framepos_t FFReadStream::GetNextKeyFrame(framepos_t frame) const |
| 115 |
{ |
| 116 |
return ERR; |
| 117 |
} |
| 118 |
|
| 119 |
framepos_t FFReadStream::GetNearestKeyFrame(framepos_t frame) const |
| 120 |
{ |
| 121 |
return ERR; |
| 122 |
} |
| 123 |
|
| 124 |
framepos_t FFReadStream::GetLength() const |
| 125 |
{ |
| 126 |
return 0x7fffffff; |
| 127 |
} |
| 128 |
|
| 129 |
double FFReadStream::GetFrameTime() const |
| 130 |
{ |
| 131 |
return 1/24.; |
| 132 |
} |
| 133 |
|
| 134 |
double FFReadStream::GetLengthTime() const |
| 135 |
{ |
| 136 |
return m_dLength; |
| 137 |
} |
| 138 |
|
| 139 |
StreamInfo* FFReadStream::GetStreamInfo() const |
| 140 |
{ |
| 141 |
AVStream* avs = m_pHandler->m_pContext->streams[m_uiSId]; |
| 142 |
uint_t s; |
| 143 |
if (m_StreamInfo.m_p->m_dLengthTime == 0.0) |
| 144 |
{ |
| 145 |
m_StreamInfo.m_p->setKfFrames(m_uiKeyMaxSize, m_uiKeyMinSize, |
| 146 |
m_uiKeyChunks, m_uiKeySize); |
| 147 |
|
| 148 |
m_StreamInfo.m_p->setFrames(m_uiDeltaMaxSize, |
| 149 |
(m_uiDeltaMinSize > m_uiDeltaMaxSize) |
| 150 |
// usually no delta frames |
| 151 |
? m_uiDeltaMaxSize : m_uiDeltaMinSize, |
| 152 |
(uint_t)(m_Offsets.size() - m_uiKeyChunks), |
| 153 |
m_uiStreamSize - m_uiKeySize); |
| 154 |
|
| 155 |
m_StreamInfo.m_p->m_dLengthTime = GetLengthTime(); |
| 156 |
m_StreamInfo.m_p->m_iQuality = 0; |
| 157 |
m_StreamInfo.m_p->m_iSampleSize = 1;//m_Header.dwSampleSize; |
| 158 |
|
| 159 |
switch (avs->codecpar->codec_type) |
| 160 |
{ |
| 161 |
case AVMEDIA_TYPE_AUDIO: |
| 162 |
m_StreamInfo.m_p->setAudio(avs->codecpar->ch_layout.nb_channels, |
| 163 |
avs->codecpar->sample_rate, |
| 164 |
avs->codecpar->frame_size); |
| 165 |
m_StreamInfo.m_p->m_Type = StreamInfo::Audio; |
| 166 |
m_StreamInfo.m_p->m_uiFormat = avs->codecpar->codec_tag; |
| 167 |
AVM_WRITE("FF stream", "Audio Format: %.4s (0x%x)\n", |
| 168 |
(const char*)&avs->codecpar->codec_tag, avs->codecpar->codec_tag); |
| 169 |
break; |
| 170 |
case AVMEDIA_TYPE_VIDEO: |
| 171 |
m_StreamInfo.m_p->setVideo(avs->codecpar->width, avs->codecpar->height, |
| 172 |
0, (float)avs->codecpar->sample_aspect_ratio.num / |
| 173 |
(float)avs->codecpar->sample_aspect_ratio.den); |
| 174 |
m_StreamInfo.m_p->m_Type = StreamInfo::Video; |
| 175 |
m_StreamInfo.m_p->m_uiFormat = avs->codecpar->codec_tag; |
| 176 |
AVM_WRITE("FF stream", "Codec tag format %.4s\n", (char*) &m_StreamInfo.m_p->m_uiFormat); |
| 177 |
break; |
| 178 |
default: |
| 179 |
return 0; |
| 180 |
} |
| 181 |
if (m_StreamInfo.m_p->m_uiFormat == 0) { |
| 182 |
m_StreamInfo.m_p->m_uiFormat = get_fcc(avs->codecpar->codec_id); |
| 183 |
|
| 184 |
if (m_StreamInfo.m_p->m_uiFormat == 0) |
| 185 |
AVM_WRITE("FF stream", "StreamInfo extension neeeded\n"); |
| 186 |
} |
| 187 |
} |
| 188 |
|
| 189 |
return new StreamInfo(m_StreamInfo); |
| 190 |
} |
| 191 |
|
| 192 |
double FFReadStream::GetTime(framepos_t lSample) const |
| 193 |
{ |
| 194 |
if (lSample == ERR) |
| 195 |
return m_dTimestamp; |
| 196 |
|
| 197 |
return 0.; |
| 198 |
} |
| 199 |
|
| 200 |
size_t FFReadStream::GetSampleSize() const |
| 201 |
{ |
| 202 |
return 0; |
| 203 |
} |
| 204 |
|
| 205 |
IStream::StreamType FFReadStream::GetType() const |
| 206 |
{ |
| 207 |
switch (m_pHandler->m_pContext->streams[m_uiSId]->codecpar->codec_type) |
| 208 |
{ |
| 209 |
case AVMEDIA_TYPE_AUDIO: return IStream::Audio; |
| 210 |
case AVMEDIA_TYPE_VIDEO: return IStream::Video; |
| 211 |
default: return IStream::Other; |
| 212 |
} |
| 213 |
} |
| 214 |
|
| 215 |
size_t FFReadStream::GetFormat(void *format, size_t size) const |
| 216 |
{ |
| 217 |
AVStream* avs = m_pHandler->m_pContext->streams[m_uiSId]; |
| 218 |
|
| 219 |
int tag = get_fcc(avs->codecpar->codec_id); |
| 220 |
switch (avs->codecpar->codec_type) |
| 221 |
{ |
| 222 |
case AVMEDIA_TYPE_AUDIO: |
| 223 |
if (format && size >= sizeof(WAVEFORMATEX)) |
| 224 |
{ |
| 225 |
WAVEFORMATEX& wfx = *(WAVEFORMATEX*)format; |
| 226 |
FFMPEGWAVEFORMATEX& ffwfx = *(FFMPEGWAVEFORMATEX*)format; |
| 227 |
if (tag == 0) { |
| 228 |
if (size < sizeof(FFMPEGWAVEFORMATEX)) |
| 229 |
return 0; |
| 230 |
memset(&ffwfx, 0, sizeof(ffwfx)); |
| 231 |
// using extension - there is no free place in original WAVEFORMATEX |
| 232 |
wfx.wFormatTag = WAVE_FORMAT_EXTENSIBLE; |
| 233 |
avm_set_le32(&ffwfx.wfex.SubFormat.f1, CodecInfo::FFMPEG); |
| 234 |
avm_set_le32(&ffwfx.dwCodecID, avs->codecpar->codec_id); |
| 235 |
} else { |
| 236 |
memset(&wfx, 0, sizeof(wfx)); |
| 237 |
wfx.wFormatTag = (uint16_t)tag; |
| 238 |
} |
| 239 |
|
| 240 |
//if (avs->codec->codec_tag == 0) wf->wFormatTag = av_codec_get_fourcc(avs->codec->codec_id); |
| 241 |
//printf("CODEC %x %x %x\n", wf.wFormatTag, avs->codec->codec_id, avs->codec->codec_tag); |
| 242 |
wfx.nChannels = (uint16_t)avs->codecpar->ch_layout.nb_channels; |
| 243 |
wfx.nSamplesPerSec = avs->codecpar->sample_rate; |
| 244 |
wfx.nAvgBytesPerSec = avs->codecpar->bit_rate / 8; |
| 245 |
//printf("SAMP:%d AVGBYTES:%d ALIGN:%d BITS:%d\n", avs->codec->sample_rate, avs->codec->bit_rate, avs->codecpar->block_align, avs->codec->bits_per_coded_sample); |
| 246 |
wfx.nBlockAlign = (uint16_t)avs->codecpar->block_align; |
| 247 |
wfx.wBitsPerSample = (uint16_t)avs->codecpar->bits_per_coded_sample; |
| 248 |
wfx.cbSize = tag ? 0 : sizeof(FFMPEGWAVEFORMATEX) - sizeof(WAVEFORMATEX); |
| 249 |
if (avs->codecpar->extradata |
| 250 |
&& size >= (sizeof(WAVEFORMATEX) + wfx.cbSize + avs->codecpar->extradata_size)) |
| 251 |
{ |
| 252 |
memcpy((uint8_t*)(&wfx + 1) + wfx.cbSize, avs->codecpar->extradata, avs->codecpar->extradata_size); |
| 253 |
wfx.cbSize = (uint16_t)(wfx.cbSize + avs->codecpar->extradata_size); |
| 254 |
} |
| 255 |
|
| 256 |
if (avs->codecpar->codec_id == AV_CODEC_ID_AAC) { |
| 257 |
// hmm currenly hack - ffmpeg seems to fail properly detect this stream |
| 258 |
wfx.nChannels = 2; |
| 259 |
wfx.nSamplesPerSec = 44100; |
| 260 |
wfx.nAvgBytesPerSec = 16000; |
| 261 |
wfx.wBitsPerSample = 16; |
| 262 |
} |
| 263 |
|
| 264 |
///printf("AUDIO %d %x %x %d\n", avs->codec->extradata_size, wf->wFormatTag, avs->codec->codec_tag, avs->codec->codec_id); |
| 265 |
} |
| 266 |
return (tag ? sizeof(WAVEFORMATEX) : sizeof(FFMPEGWAVEFORMATEX)) |
| 267 |
+ ((avs->codecpar->extradata) ? avs->codecpar->extradata_size : 0); |
| 268 |
case AVMEDIA_TYPE_VIDEO: |
| 269 |
if (format && size >= sizeof(BITMAPINFOHEADER)) |
| 270 |
{ |
| 271 |
memset(format, 0, sizeof(BITMAPINFOHEADER)); |
| 272 |
BITMAPINFOHEADER& bih = *(BITMAPINFOHEADER*)format; |
| 273 |
//printf("FORMAT %p %d %d\n", format, m_uiSId, avc->width); |
| 274 |
bih.biSize = sizeof(BITMAPINFOHEADER); |
| 275 |
bih.biWidth = avs->codecpar->width; |
| 276 |
bih.biHeight = avs->codecpar->height; |
| 277 |
bih.biPlanes = 1; |
| 278 |
bih.biCompression = get_fcc(avs->codecpar->codec_id); |
| 279 |
bih.biBitCount = (uint16_t)avs->codecpar->bits_per_coded_sample; |
| 280 |
// hack which might be eventually usefull |
| 281 |
//memcpy(&bih->biXPelsPerMeter, &m_pHandler->m_pContext, sizeof(void*)); |
| 282 |
if (!bih.biCompression) { |
| 283 |
bih.biCompression = CodecInfo::FFMPEG; |
| 284 |
bih.biSizeImage = avs->codecpar->codec_id; |
| 285 |
} |
| 286 |
if (avs->codecpar->extradata && size >= (sizeof(BITMAPINFOHEADER) + avs->codecpar->extradata_size)) |
| 287 |
{ |
| 288 |
bih.biSize += avs->codecpar->extradata_size; |
| 289 |
memcpy(&bih + 1, avs->codecpar->extradata, avs->codecpar->extradata_size); |
| 290 |
//printf("COPY EXTRA %d\n", avs->extradata_size); |
| 291 |
//for (unsigned i = 0; i < size; i++) printf("%d 0x%x\n", i, ((uint8_t*)format)[i]); |
| 292 |
} |
| 293 |
//BitmapInfo(*bih).Print(); |
| 294 |
} |
| 295 |
return sizeof(BITMAPINFOHEADER) |
| 296 |
+ ((avs->codecpar->extradata) ? avs->codecpar->extradata_size : 0); |
| 297 |
default: |
| 298 |
return 0; |
| 299 |
} |
| 300 |
} |
| 301 |
|
| 302 |
bool FFReadStream::IsKeyFrame(framepos_t frame) const |
| 303 |
{ |
| 304 |
if (frame == ERR && m_Packets.size()) |
| 305 |
return (m_Packets.front()->GetFlags() & KEYFRAME); |
| 306 |
|
| 307 |
AVM_WRITE("FF stream", "IsKeyFrame unimplemented!\n"); |
| 308 |
return true; |
| 309 |
} |
| 310 |
|
| 311 |
StreamPacket* FFReadStream::ReadPacket() |
| 312 |
{ |
| 313 |
for (size_t i = 0; i < m_Packets.capacity() - 2; ++i) |
| 314 |
{ |
| 315 |
if (m_Packets.size() > 0) |
| 316 |
break; |
| 317 |
|
| 318 |
if (m_pHandler->readPacket() < 0) |
| 319 |
{ |
| 320 |
if (m_dLength < m_dTimestamp) |
| 321 |
m_dLength = m_dTimestamp; |
| 322 |
return 0; |
| 323 |
} |
| 324 |
} |
| 325 |
//printf("PACKET SIZE %d %d\n", m_Packets.size(), m_Packets.capacity()); |
| 326 |
if (!m_Packets.size()) |
| 327 |
return 0; |
| 328 |
|
| 329 |
Locker locker(m_pHandler->m_Mutex); |
| 330 |
StreamPacket* p = m_Packets.front(); |
| 331 |
m_Packets.pop(); |
| 332 |
m_dTimestamp = (double)p->GetTimestamp() / (double)AV_TIME_BASE; |
| 333 |
|
| 334 |
if (m_dLength < m_dTimestamp) |
| 335 |
m_dLength = m_dTimestamp; |
| 336 |
|
| 337 |
//printf("FFREADSTREAMPACKET %f sid:%d qsz:%" PRIsz " s:%d frm: %d\n", m_dTimestamp, m_uiSId, m_Packets.size(), p->size, m_pAvStream->codec->frame_number); |
| 338 |
return p; |
| 339 |
} |
| 340 |
|
| 341 |
int FFReadStream::Seek(framepos_t pos) |
| 342 |
{ |
| 343 |
AVM_WRITE("FF stream", "SeekPos: %d\n", pos); |
| 344 |
if (pos == 0) |
| 345 |
{ |
| 346 |
m_pHandler->seek(0); |
| 347 |
return 0; |
| 348 |
} |
| 349 |
return -1; |
| 350 |
} |
| 351 |
|
| 352 |
int FFReadStream::SeekTime(double time) |
| 353 |
{ |
| 354 |
AVM_WRITE("FF stream", "SeekTime: %f\n", time); |
| 355 |
return m_pHandler->seek(time); |
| 356 |
if (time < 1.) |
| 357 |
{ |
| 358 |
if (m_pAvStream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) |
| 359 |
// check if more streams are available |
| 360 |
// and seek only with the video |
| 361 |
return 0; |
| 362 |
m_pHandler->seek(0); |
| 363 |
return 0; |
| 364 |
} |
| 365 |
return -1; |
| 366 |
} |
| 367 |
|
| 368 |
int FFReadStream::SkipFrame() |
| 369 |
{ |
| 370 |
AVM_WRITE("FF stream", "SkipFrame\n"); |
| 371 |
StreamPacket* p = ReadPacket(); |
| 372 |
if (p) |
| 373 |
p->Release(); |
| 374 |
return p ? 0 : -1; |
| 375 |
} |
| 376 |
|
| 377 |
int FFReadStream::SkipTo(double pos) |
| 378 |
{ |
| 379 |
AVM_WRITE("FF stream", "SkipTo: %f\n", pos); |
| 380 |
while (pos < GetTime()) |
| 381 |
SkipFrame(); |
| 382 |
return 0; |
| 383 |
} |
| 384 |
|
| 385 |
AVM_END_NAMESPACE; |