MPEG4Writer.h revision b21c564ce47041f9dd3ab65e36fed57c4937a42d
1/* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef MPEG4_WRITER_H_ 18 19#define MPEG4_WRITER_H_ 20 21#include <stdio.h> 22 23#include <media/stagefright/MediaWriter.h> 24#include <utils/List.h> 25#include <utils/threads.h> 26 27namespace android { 28 29class MediaBuffer; 30class MediaSource; 31class MetaData; 32 33class MPEG4Writer : public MediaWriter { 34public: 35 MPEG4Writer(const char *filename); 36 MPEG4Writer(int fd); 37 38 virtual status_t addSource(const sp<MediaSource> &source); 39 virtual status_t start(MetaData *param = NULL); 40 virtual status_t stop(); 41 virtual status_t pause(); 42 virtual bool reachedEOS(); 43 virtual status_t dump(int fd, const Vector<String16>& args); 44 45 void beginBox(const char *fourcc); 46 void writeInt8(int8_t x); 47 void writeInt16(int16_t x); 48 void writeInt32(int32_t x); 49 void writeInt64(int64_t x); 50 void writeCString(const char *s); 51 void writeFourcc(const char *fourcc); 52 void write(const void *data, size_t size); 53 void endBox(); 54 uint32_t interleaveDuration() const { return mInterleaveDurationUs; } 55 status_t setInterleaveDuration(uint32_t duration); 56 int32_t getTimeScale() const { return mTimeScale; } 57 58protected: 59 virtual ~MPEG4Writer(); 60 61private: 62 class Track; 63 64 int mFd; 65 status_t mInitCheck; 66 bool mUse4ByteNalLength; 67 bool mUse32BitOffset; 68 bool mIsFileSizeLimitExplicitlyRequested; 69 bool mPaused; 70 bool mStarted; 71 off64_t mOffset; 72 off_t mMdatOffset; 73 uint8_t *mMoovBoxBuffer; 74 off64_t mMoovBoxBufferOffset; 75 bool mWriteMoovBoxToMemory; 76 off64_t mFreeBoxOffset; 77 bool mStreamableFile; 78 off64_t mEstimatedMoovBoxSize; 79 uint32_t mInterleaveDurationUs; 80 int32_t mTimeScale; 81 int64_t mStartTimestampUs; 82 83 Mutex mLock; 84 85 List<Track *> mTracks; 86 87 List<off64_t> mBoxes; 88 89 void setStartTimestampUs(int64_t timeUs); 90 int64_t getStartTimestampUs(); // Not const 91 status_t startTracks(MetaData *params); 92 size_t numTracks(); 93 int64_t estimateMoovBoxSize(int32_t bitRate); 94 95 struct Chunk { 96 Track *mTrack; // Owner 97 int64_t mTimeStampUs; // Timestamp of the 1st sample 98 List<MediaBuffer *> mSamples; // Sample data 99 100 // Convenient constructor 101 Chunk(): mTrack(NULL), mTimeStampUs(0) {} 102 103 Chunk(Track *track, int64_t timeUs, List<MediaBuffer *> samples) 104 : mTrack(track), mTimeStampUs(timeUs), mSamples(samples) { 105 } 106 107 }; 108 struct ChunkInfo { 109 Track *mTrack; // Owner 110 List<Chunk> mChunks; // Remaining chunks to be written 111 }; 112 113 bool mIsFirstChunk; 114 volatile bool mDone; // Writer thread is done? 115 pthread_t mThread; // Thread id for the writer 116 List<ChunkInfo> mChunkInfos; // Chunk infos 117 Condition mChunkReadyCondition; // Signal that chunks are available 118 119 // Writer thread handling 120 status_t startWriterThread(); 121 void stopWriterThread(); 122 static void *ThreadWrapper(void *me); 123 void threadFunc(); 124 125 // Buffer a single chunk to be written out later. 126 void bufferChunk(const Chunk& chunk); 127 128 // Write all buffered chunks from all tracks 129 void writeAllChunks(); 130 131 // Retrieve the proper chunk to write if there is one 132 // Return true if a chunk is found; otherwise, return false. 133 bool findChunkToWrite(Chunk *chunk); 134 135 // Actually write the given chunk to the file. 136 void writeChunkToFile(Chunk* chunk); 137 138 // Adjust other track media clock (presumably wall clock) 139 // based on audio track media clock with the drift time. 140 int64_t mDriftTimeUs; 141 void setDriftTimeUs(int64_t driftTimeUs); 142 int64_t getDriftTimeUs(); 143 144 // Return whether the nal length is 4 bytes or 2 bytes 145 // Only makes sense for H.264/AVC 146 bool useNalLengthFour(); 147 148 void lock(); 149 void unlock(); 150 151 // Acquire lock before calling these methods 152 off64_t addSample_l(MediaBuffer *buffer); 153 off64_t addLengthPrefixedSample_l(MediaBuffer *buffer); 154 155 inline size_t write(const void *ptr, size_t size, size_t nmemb); 156 bool exceedsFileSizeLimit(); 157 bool use32BitFileOffset() const; 158 bool exceedsFileDurationLimit(); 159 bool isFileStreamable() const; 160 void trackProgressStatus(size_t trackId, int64_t timeUs, status_t err = OK); 161 void writeCompositionMatrix(int32_t degrees); 162 void writeMvhdBox(int64_t durationUs); 163 void writeMoovBox(int64_t durationUs); 164 void writeFtypBox(MetaData *param); 165 166 MPEG4Writer(const MPEG4Writer &); 167 MPEG4Writer &operator=(const MPEG4Writer &); 168}; 169 170} // namespace android 171 172#endif // MPEG4_WRITER_H_ 173