git.osdn.net Git - android-x86/frameworks-av.git/blob

1 /*

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 *************************************************************************

18 * @file VideoEditorVideoEncoder.cpp

19 * @brief StageFright shell video encoder

20 *************************************************************************

21 */

22 #define LOG_NDEBUG 1

23 #define LOG_TAG "VIDEOEDITOR_VIDEOENCODER"

25 /*******************

26 * HEADERS *

27 *******************/

28 #include "M4OSA_Debug.h"

29 #include "M4SYS_AccessUnit.h"

30 #include "VideoEditorVideoEncoder.h"

31 #include "VideoEditorUtils.h"

32 #include "MediaBufferPuller.h"

33 #include <I420ColorConverter.h>

35 #include <unistd.h>

36 #include "utils/Log.h"

37 #include "utils/Vector.h"

38 #include <media/stagefright/foundation/ADebug.h>

39 #include <media/stagefright/MediaSource.h>

40 #include <media/stagefright/MediaDefs.h>

41 #include <media/stagefright/MetaData.h>

42 #include <media/stagefright/OMXClient.h>

43 #include <media/stagefright/OMXCodec.h>

44 #include <media/MediaProfiles.h>

45 #include "OMX_Video.h"

47 /********************

48 * DEFINITIONS *

49 ********************/

51 // Force using hardware encoder

52 #define VIDEOEDITOR_FORCECODEC kHardwareCodecsOnly

54 #if !defined(VIDEOEDITOR_FORCECODEC)

55 #error "Cannot force DSI retrieval if codec type is not fixed"

56 #endif

58 /********************

59 * SOURCE CLASS *

60 ********************/

62 namespace android {

64 struct VideoEditorVideoEncoderSource : public MediaSource {

65 public:

66 static sp<VideoEditorVideoEncoderSource> Create(

67 const sp<MetaData> &format);

68 virtual status_t start(MetaData *params = NULL);

69 virtual status_t stop();

70 virtual sp<MetaData> getFormat();

71 virtual status_t read(MediaBuffer **buffer,

72 const ReadOptions *options = NULL);

73 virtual int32_t storeBuffer(MediaBuffer *buffer);

74 virtual int32_t getNumberOfBuffersInQueue();

76 protected:

77 virtual ~VideoEditorVideoEncoderSource();

79 private:

80 struct MediaBufferChain {

81 MediaBuffer* buffer;

82 MediaBufferChain* nextLink;

83 };

84 enum State {

85 CREATED,

86 STARTED,

87 ERROR

88 };

89 VideoEditorVideoEncoderSource(const sp<MetaData> &format);

91 // Don't call me

92 VideoEditorVideoEncoderSource(const VideoEditorVideoEncoderSource &);

93 VideoEditorVideoEncoderSource &operator=(

94 const VideoEditorVideoEncoderSource &);

96 MediaBufferChain* mFirstBufferLink;

97 MediaBufferChain* mLastBufferLink;

98 int32_t mNbBuffer;

99 bool mIsEOS;

100 State mState;

101 sp<MetaData> mEncFormat;

102 Mutex mLock;

103 Condition mBufferCond;

104 };

105

106 sp<VideoEditorVideoEncoderSource> VideoEditorVideoEncoderSource::Create(

107 const sp<MetaData> &format) {

108

109 sp<VideoEditorVideoEncoderSource> aSource =

110 new VideoEditorVideoEncoderSource(format);

111 return aSource;

112 }

113

114 VideoEditorVideoEncoderSource::VideoEditorVideoEncoderSource(

115 const sp<MetaData> &format):

116 mFirstBufferLink(NULL),

117 mLastBufferLink(NULL),

118 mNbBuffer(0),

119 mIsEOS(false),

120 mState(CREATED),

121 mEncFormat(format) {

122 ALOGV("VideoEditorVideoEncoderSource::VideoEditorVideoEncoderSource");

123 }

124

125 VideoEditorVideoEncoderSource::~VideoEditorVideoEncoderSource() {

126

127 // Safety clean up

128 if( STARTED == mState ) {

129 stop();

130 }

131 }

132

133 status_t VideoEditorVideoEncoderSource::start(MetaData *meta) {

134 status_t err = OK;

135

136 ALOGV("VideoEditorVideoEncoderSource::start() begin");

137

138 if( CREATED != mState ) {

139 ALOGV("VideoEditorVideoEncoderSource::start: invalid state %d", mState);

140 return UNKNOWN_ERROR;

141 }

142 mState = STARTED;

143

144 ALOGV("VideoEditorVideoEncoderSource::start() END (0x%x)", err);

145 return err;

146 }

147

148 status_t VideoEditorVideoEncoderSource::stop() {

149 status_t err = OK;

150

151 ALOGV("VideoEditorVideoEncoderSource::stop() begin");

152

153 if( STARTED != mState ) {

154 ALOGV("VideoEditorVideoEncoderSource::stop: invalid state %d", mState);

155 return UNKNOWN_ERROR;

156 }

157

158 // Release the buffer chain

159 int32_t i = 0;

160 MediaBufferChain* tmpLink = NULL;

161 while( mFirstBufferLink ) {

162 i++;

163 tmpLink = mFirstBufferLink;

164 mFirstBufferLink = mFirstBufferLink->nextLink;

165 delete tmpLink;

166 }

167 ALOGV("VideoEditorVideoEncoderSource::stop : %d buffer remained", i);

168 mFirstBufferLink = NULL;

169 mLastBufferLink = NULL;

170

171 mState = CREATED;

172

173 ALOGV("VideoEditorVideoEncoderSource::stop() END (0x%x)", err);

174 return err;

175 }

176

177 sp<MetaData> VideoEditorVideoEncoderSource::getFormat() {

178

179 ALOGV("VideoEditorVideoEncoderSource::getFormat");

180 return mEncFormat;

181 }

182

183 status_t VideoEditorVideoEncoderSource::read(MediaBuffer **buffer,

184 const ReadOptions *options) {

185 Mutex::Autolock autolock(mLock);

186 MediaSource::ReadOptions readOptions;

187 status_t err = OK;

188 MediaBufferChain* tmpLink = NULL;

189

190 ALOGV("VideoEditorVideoEncoderSource::read() begin");

191

192 if ( STARTED != mState ) {

193 ALOGV("VideoEditorVideoEncoderSource::read: invalid state %d", mState);

194 return UNKNOWN_ERROR;

195 }

196

197 while (mFirstBufferLink == NULL && !mIsEOS) {

198 mBufferCond.wait(mLock);

199 }

200

201 // End of stream?

202 if (mFirstBufferLink == NULL) {

203 *buffer = NULL;

204 ALOGV("VideoEditorVideoEncoderSource::read : EOS");

205 return ERROR_END_OF_STREAM;

206 }

207

208 // Get a buffer from the chain

209 *buffer = mFirstBufferLink->buffer;

210 tmpLink = mFirstBufferLink;

211 mFirstBufferLink = mFirstBufferLink->nextLink;

212

213 if ( NULL == mFirstBufferLink ) {

214 mLastBufferLink = NULL;

215 }

216 delete tmpLink;

217 mNbBuffer--;

218

219 ALOGV("VideoEditorVideoEncoderSource::read() END (0x%x)", err);

220 return err;

221 }

222

223 int32_t VideoEditorVideoEncoderSource::storeBuffer(MediaBuffer *buffer) {

224 Mutex::Autolock autolock(mLock);

225 status_t err = OK;

226

227 ALOGV("VideoEditorVideoEncoderSource::storeBuffer() begin");

228

229 if( NULL == buffer ) {

230 ALOGV("VideoEditorVideoEncoderSource::storeBuffer : reached EOS");

231 mIsEOS = true;

232 } else {

233 MediaBufferChain* newLink = new MediaBufferChain;

234 newLink->buffer = buffer;

235 newLink->nextLink = NULL;

236 if( NULL != mLastBufferLink ) {

237 mLastBufferLink->nextLink = newLink;

238 } else {

239 mFirstBufferLink = newLink;

240 }

241 mLastBufferLink = newLink;

242 mNbBuffer++;

243 }

244 mBufferCond.signal();

245 ALOGV("VideoEditorVideoEncoderSource::storeBuffer() end");

246 return mNbBuffer;

247 }

248

249 int32_t VideoEditorVideoEncoderSource::getNumberOfBuffersInQueue() {

250 Mutex::Autolock autolock(mLock);

251 return mNbBuffer;

252 }

253

254 /**

255 ******************************************************************************

256 * structure VideoEditorVideoEncoder_Context

257 * @brief This structure defines the context of the StageFright video encoder

258 * shell

259 ******************************************************************************

260 */

261 typedef enum {

262 CREATED = 0x1,

263 OPENED = 0x2,

264 STARTED = 0x4,

265 BUFFERING = 0x8,

266 READING = 0x10

267 } VideoEditorVideoEncoder_State;

268

269 typedef struct {

270 VideoEditorVideoEncoder_State mState;

271 M4ENCODER_Format mFormat;

272 M4WRITER_DataInterface* mWriterDataInterface;

273 M4VPP_apply_fct* mPreProcFunction;

274 M4VPP_Context mPreProcContext;

275 M4SYS_AccessUnit* mAccessUnit;

276 M4ENCODER_Params* mCodecParams;

277 M4ENCODER_Header mHeader;

278 H264MCS_ProcessEncodedNALU_fct* mH264NALUPostProcessFct;

279 M4OSA_Context mH264NALUPostProcessCtx;

280 M4OSA_UInt32 mLastCTS;

281 sp<VideoEditorVideoEncoderSource> mEncoderSource;

282 OMXClient mClient;

283 sp<MediaSource> mEncoder;

284 OMX_COLOR_FORMATTYPE mEncoderColorFormat;

285 MediaBufferPuller* mPuller;

286 I420ColorConverter* mI420ColorConverter;

287

288 uint32_t mNbInputFrames;

289 double mFirstInputCts;

290 double mLastInputCts;

291 uint32_t mNbOutputFrames;

292 int64_t mFirstOutputCts;

293 int64_t mLastOutputCts;

294

295 MediaProfiles *mVideoEditorProfile;

296 int32_t mMaxPrefetchFrames;

297 } VideoEditorVideoEncoder_Context;

298

299 /********************

300 * TOOLS *

301 ********************/

302

303 M4OSA_ERR VideoEditorVideoEncoder_getDSI(M4ENCODER_Context pContext,

304 sp<MetaData> metaData) {

305 M4OSA_ERR err = M4NO_ERROR;

306 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

307 status_t result = OK;

308 int32_t nbBuffer = 0;

309 int32_t stride = 0;

310 int32_t height = 0;

311 int32_t framerate = 0;

312 int32_t isCodecConfig = 0;

313 size_t size = 0;

314 uint32_t codecFlags = 0;

315 MediaBuffer* inputBuffer = NULL;

316 MediaBuffer* outputBuffer = NULL;

317 sp<VideoEditorVideoEncoderSource> encoderSource = NULL;

318 sp<MediaSource> encoder = NULL;;

319 OMXClient client;

320

321 ALOGV("VideoEditorVideoEncoder_getDSI begin");

322 // Input parameters check

323 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

324 VIDEOEDITOR_CHECK(M4OSA_NULL != metaData.get(), M4ERR_PARAMETER);

325

326 pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

327 VIDEOEDITOR_CHECK(CREATED == pEncoderContext->mState, M4ERR_STATE);

328

329 // Create the encoder source

330 encoderSource = VideoEditorVideoEncoderSource::Create(metaData);

331 VIDEOEDITOR_CHECK(NULL != encoderSource.get(), M4ERR_STATE);

332

333 // Connect to the OMX client

334 result = client.connect();

335 VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);

336

337 // Create the OMX codec

338 // VIDEOEDITOR_FORCECODEC MUST be defined here

339 codecFlags |= OMXCodec::VIDEOEDITOR_FORCECODEC;

340 encoder = OMXCodec::Create(client.interface(), metaData, true,

341 encoderSource, NULL, codecFlags);

342 VIDEOEDITOR_CHECK(NULL != encoder.get(), M4ERR_STATE);

343

344 /**

345 * Send fake frames and retrieve the DSI

346 */

347 // Send a fake frame to the source

348 metaData->findInt32(kKeyStride, &stride);

349 metaData->findInt32(kKeyHeight, &height);

350 metaData->findInt32(kKeySampleRate, &framerate);

351 size = (size_t)(stride*height*3)/2;

352 inputBuffer = new MediaBuffer(size);

353 inputBuffer->meta_data()->setInt64(kKeyTime, 0);

354 nbBuffer = encoderSource->storeBuffer(inputBuffer);

355 encoderSource->storeBuffer(NULL); // Signal EOS

356

357 // Call read once to get the DSI

358 result = encoder->start();;

359 VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);

360 result = encoder->read(&outputBuffer, NULL);

361 VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);

362 VIDEOEDITOR_CHECK(outputBuffer->meta_data()->findInt32(

363 kKeyIsCodecConfig, &isCodecConfig) && isCodecConfig, M4ERR_STATE);

364

365 VIDEOEDITOR_CHECK(M4OSA_NULL == pEncoderContext->mHeader.pBuf, M4ERR_STATE);

366 if ( M4ENCODER_kH264 == pEncoderContext->mFormat ) {

367 // For H264, format the DSI

368 result = buildAVCCodecSpecificData(

369 (uint8_t**)(&(pEncoderContext->mHeader.pBuf)),

370 (size_t*)(&(pEncoderContext->mHeader.Size)),

371 (const uint8_t*)outputBuffer->data() + outputBuffer->range_offset(),

372 outputBuffer->range_length(), encoder->getFormat().get());

373 outputBuffer->release();

374 VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);

375 } else {

376 // For MPEG4, just copy the DSI

377 pEncoderContext->mHeader.Size =

378 (M4OSA_UInt32)outputBuffer->range_length();

379 SAFE_MALLOC(pEncoderContext->mHeader.pBuf, M4OSA_Int8,

380 pEncoderContext->mHeader.Size, "Encoder header");

381 memcpy((void *)pEncoderContext->mHeader.pBuf,

382 (void *)((M4OSA_MemAddr8)(outputBuffer->data())+outputBuffer->range_offset()),

383 pEncoderContext->mHeader.Size);

384 outputBuffer->release();

385 }

386

387 result = encoder->stop();

388 VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);

389

390 cleanUp:

391 // Destroy the graph

392 if ( encoder != NULL ) { encoder.clear(); }

393 client.disconnect();

394 if ( encoderSource != NULL ) { encoderSource.clear(); }

395 if ( M4NO_ERROR == err ) {

396 ALOGV("VideoEditorVideoEncoder_getDSI no error");

397 } else {

398 ALOGV("VideoEditorVideoEncoder_getDSI ERROR 0x%X", err);

399 }

400 ALOGV("VideoEditorVideoEncoder_getDSI end");

401 return err;

402 }

403 /********************

404 * ENGINE INTERFACE *

405 ********************/

406

407 M4OSA_ERR VideoEditorVideoEncoder_cleanup(M4ENCODER_Context pContext) {

408 M4OSA_ERR err = M4NO_ERROR;

409 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

410

411 ALOGV("VideoEditorVideoEncoder_cleanup begin");

412 // Input parameters check

413 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

414

415 pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

416 VIDEOEDITOR_CHECK(CREATED == pEncoderContext->mState, M4ERR_STATE);

417

418 // Release memory

419 SAFE_FREE(pEncoderContext->mHeader.pBuf);

420 SAFE_FREE(pEncoderContext);

421 pContext = M4OSA_NULL;

422

423 cleanUp:

424 if ( M4NO_ERROR == err ) {

425 ALOGV("VideoEditorVideoEncoder_cleanup no error");

426 } else {

427 ALOGV("VideoEditorVideoEncoder_cleanup ERROR 0x%X", err);

428 }

429 ALOGV("VideoEditorVideoEncoder_cleanup end");

430 return err;

431 }

432

433 M4OSA_ERR VideoEditorVideoEncoder_init(M4ENCODER_Format format,

434 M4ENCODER_Context* pContext,

435 M4WRITER_DataInterface* pWriterDataInterface,

436 M4VPP_apply_fct* pVPPfct, M4VPP_Context pVPPctxt,

437 M4OSA_Void* pExternalAPI, M4OSA_Void* pUserData) {

438

439 M4OSA_ERR err = M4NO_ERROR;

440 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

441 int encoderInput = OMX_COLOR_FormatYUV420Planar;

442

443 ALOGV("VideoEditorVideoEncoder_init begin: format %d", format);

444 // Input parameters check

445 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

446 VIDEOEDITOR_CHECK(M4OSA_NULL != pWriterDataInterface, M4ERR_PARAMETER);

447 VIDEOEDITOR_CHECK(M4OSA_NULL != pVPPfct, M4ERR_PARAMETER);

448 VIDEOEDITOR_CHECK(M4OSA_NULL != pVPPctxt, M4ERR_PARAMETER);

449

450 // Context allocation & initialization

451 SAFE_MALLOC(pEncoderContext, VideoEditorVideoEncoder_Context, 1,

452 "VideoEditorVideoEncoder");

453 pEncoderContext->mState = CREATED;

454 pEncoderContext->mFormat = format;

455 pEncoderContext->mWriterDataInterface = pWriterDataInterface;

456 pEncoderContext->mPreProcFunction = pVPPfct;

457 pEncoderContext->mPreProcContext = pVPPctxt;

458 pEncoderContext->mPuller = NULL;

459

460 // Get color converter and determine encoder input format

461 pEncoderContext->mI420ColorConverter = new I420ColorConverter;

462 if (pEncoderContext->mI420ColorConverter->isLoaded()) {

463 encoderInput = pEncoderContext->mI420ColorConverter->getEncoderInputFormat();

464 }

465 if (encoderInput == OMX_COLOR_FormatYUV420Planar) {

466 delete pEncoderContext->mI420ColorConverter;

467 pEncoderContext->mI420ColorConverter = NULL;

468 }

469 pEncoderContext->mEncoderColorFormat = (OMX_COLOR_FORMATTYPE)encoderInput;

470 ALOGI("encoder input format = 0x%X\n", encoderInput);

471

472 *pContext = pEncoderContext;

473

474 cleanUp:

475 if ( M4NO_ERROR == err ) {

476 ALOGV("VideoEditorVideoEncoder_init no error");

477 } else {

478 VideoEditorVideoEncoder_cleanup(pEncoderContext);

479 *pContext = M4OSA_NULL;

480 ALOGV("VideoEditorVideoEncoder_init ERROR 0x%X", err);

481 }

482 ALOGV("VideoEditorVideoEncoder_init end");

483 return err;

484 }

485

486 M4OSA_ERR VideoEditorVideoEncoder_init_H263(M4ENCODER_Context* pContext,

487 M4WRITER_DataInterface* pWriterDataInterface, M4VPP_apply_fct* pVPPfct,

488 M4VPP_Context pVPPctxt, M4OSA_Void* pExternalAPI, M4OSA_Void* pUserData)

489 {

490

491 return VideoEditorVideoEncoder_init(M4ENCODER_kH263, pContext,

492 pWriterDataInterface, pVPPfct, pVPPctxt, pExternalAPI, pUserData);

493 }

494

495

496 M4OSA_ERR VideoEditorVideoEncoder_init_MPEG4(M4ENCODER_Context* pContext,

497 M4WRITER_DataInterface* pWriterDataInterface, M4VPP_apply_fct* pVPPfct,

498 M4VPP_Context pVPPctxt, M4OSA_Void* pExternalAPI, M4OSA_Void* pUserData)

499 {

500

501 return VideoEditorVideoEncoder_init(M4ENCODER_kMPEG4, pContext,

502 pWriterDataInterface, pVPPfct, pVPPctxt, pExternalAPI, pUserData);

503 }

504

505

506 M4OSA_ERR VideoEditorVideoEncoder_init_H264(M4ENCODER_Context* pContext,

507 M4WRITER_DataInterface* pWriterDataInterface, M4VPP_apply_fct* pVPPfct,

508 M4VPP_Context pVPPctxt, M4OSA_Void* pExternalAPI, M4OSA_Void* pUserData)

509 {

510

511 return VideoEditorVideoEncoder_init(M4ENCODER_kH264, pContext,

512 pWriterDataInterface, pVPPfct, pVPPctxt, pExternalAPI, pUserData);

513 }

514

515 M4OSA_ERR VideoEditorVideoEncoder_close(M4ENCODER_Context pContext) {

516 M4OSA_ERR err = M4NO_ERROR;

517 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

518

519 ALOGV("VideoEditorVideoEncoder_close begin");

520 // Input parameters check

521 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

522

523 pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

524 VIDEOEDITOR_CHECK(OPENED == pEncoderContext->mState, M4ERR_STATE);

525

526 // Release memory

527 SAFE_FREE(pEncoderContext->mCodecParams);

528

529 // Destroy the graph

530 pEncoderContext->mEncoder.clear();

531 pEncoderContext->mClient.disconnect();

532 pEncoderContext->mEncoderSource.clear();

533

534 delete pEncoderContext->mPuller;

535 pEncoderContext->mPuller = NULL;

536

537 delete pEncoderContext->mI420ColorConverter;

538 pEncoderContext->mI420ColorConverter = NULL;

539

540 // Set the new state

541 pEncoderContext->mState = CREATED;

542

543 cleanUp:

544 if( M4NO_ERROR == err ) {

545 ALOGV("VideoEditorVideoEncoder_close no error");

546 } else {

547 ALOGV("VideoEditorVideoEncoder_close ERROR 0x%X", err);

548 }

549 ALOGV("VideoEditorVideoEncoder_close end");

550 return err;

551 }

552

553

554 M4OSA_ERR VideoEditorVideoEncoder_open(M4ENCODER_Context pContext,

555 M4SYS_AccessUnit* pAU, M4OSA_Void* pParams) {

556 M4OSA_ERR err = M4NO_ERROR;

557 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

558 M4ENCODER_Params* pCodecParams = M4OSA_NULL;

559 status_t result = OK;

560 sp<MetaData> encoderMetadata = NULL;

561 const char* mime = NULL;

562 int32_t iProfile = 0;

563 int32_t iLevel = 0;

564

565 int32_t iFrameRate = 0;

566 uint32_t codecFlags = 0;

567

568 ALOGV(">>> VideoEditorVideoEncoder_open begin");

569 // Input parameters check

570 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

571 VIDEOEDITOR_CHECK(M4OSA_NULL != pAU, M4ERR_PARAMETER);

572 VIDEOEDITOR_CHECK(M4OSA_NULL != pParams, M4ERR_PARAMETER);

573

574 pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

575 pCodecParams = (M4ENCODER_Params*)pParams;

576 VIDEOEDITOR_CHECK(CREATED == pEncoderContext->mState, M4ERR_STATE);

577

578 // Context initialization

579 pEncoderContext->mAccessUnit = pAU;

580 pEncoderContext->mVideoEditorProfile = MediaProfiles::getInstance();

581 pEncoderContext->mMaxPrefetchFrames =

582 pEncoderContext->mVideoEditorProfile->getVideoEditorCapParamByName(

583 "maxPrefetchYUVFrames");

584

585 // Allocate & initialize the encoding parameters

586 SAFE_MALLOC(pEncoderContext->mCodecParams, M4ENCODER_Params, 1,

587 "VideoEditorVideoEncoder");

588

589

590 pEncoderContext->mCodecParams->InputFormat = pCodecParams->InputFormat;

591 pEncoderContext->mCodecParams->InputFrameWidth =

592 pCodecParams->InputFrameWidth;

593 pEncoderContext->mCodecParams->InputFrameHeight =

594 pCodecParams->InputFrameHeight;

595 pEncoderContext->mCodecParams->FrameWidth = pCodecParams->FrameWidth;

596 pEncoderContext->mCodecParams->FrameHeight = pCodecParams->FrameHeight;

597 pEncoderContext->mCodecParams->Bitrate = pCodecParams->Bitrate;

598 pEncoderContext->mCodecParams->FrameRate = pCodecParams->FrameRate;

599 pEncoderContext->mCodecParams->Format = pCodecParams->Format;

600 pEncoderContext->mCodecParams->videoProfile = pCodecParams->videoProfile;

601 pEncoderContext->mCodecParams->videoLevel= pCodecParams->videoLevel;

602

603 // Check output format consistency and resolution

604 VIDEOEDITOR_CHECK(

605 pEncoderContext->mCodecParams->Format == pEncoderContext->mFormat,

606 M4ERR_PARAMETER);

607 VIDEOEDITOR_CHECK(0 == pEncoderContext->mCodecParams->FrameWidth % 16,

608 M4ERR_PARAMETER);

609 VIDEOEDITOR_CHECK(0 == pEncoderContext->mCodecParams->FrameHeight % 16,

610 M4ERR_PARAMETER);

611

612 /**

613 * StageFright graph building

614 */

615

616 // Create the meta data for the encoder

617 encoderMetadata = new MetaData;

618 switch( pEncoderContext->mCodecParams->Format ) {

619 case M4ENCODER_kH263:

620 mime = MEDIA_MIMETYPE_VIDEO_H263;

621 break;

622 case M4ENCODER_kMPEG4:

623 mime = MEDIA_MIMETYPE_VIDEO_MPEG4;

624 break;

625 case M4ENCODER_kH264:

626 mime = MEDIA_MIMETYPE_VIDEO_AVC;

627 break;

628 default:

629 VIDEOEDITOR_CHECK(!"VideoEncoder_open : incorrect input format",

630 M4ERR_PARAMETER);

631 break;

632 }

633 iProfile = pEncoderContext->mCodecParams->videoProfile;

634 iLevel = pEncoderContext->mCodecParams->videoLevel;

635 ALOGV("Encoder mime %s profile %d, level %d",

636 mime,iProfile, iLevel);

637 ALOGV("Encoder w %d, h %d, bitrate %d, fps %d",

638 pEncoderContext->mCodecParams->FrameWidth,

639 pEncoderContext->mCodecParams->FrameHeight,

640 pEncoderContext->mCodecParams->Bitrate,

641 pEncoderContext->mCodecParams->FrameRate);

642 CHECK(iProfile != 0x7fffffff);

643 CHECK(iLevel != 0x7fffffff);

644

645 encoderMetadata->setCString(kKeyMIMEType, mime);

646 encoderMetadata->setInt32(kKeyVideoProfile, iProfile);

647 //FIXME:

648 // Temp: Do not set the level for Mpeg4 / H.263 Enc

649 // as OMX.Nvidia.mp4.encoder and OMX.Nvidia.h263.encoder

650 // return 0x80001019

651 if (pEncoderContext->mCodecParams->Format == M4ENCODER_kH264) {

652 encoderMetadata->setInt32(kKeyVideoLevel, iLevel);

653 }

654 encoderMetadata->setInt32(kKeyWidth,

655 (int32_t)pEncoderContext->mCodecParams->FrameWidth);

656 encoderMetadata->setInt32(kKeyStride,

657 (int32_t)pEncoderContext->mCodecParams->FrameWidth);

658 encoderMetadata->setInt32(kKeyHeight,

659 (int32_t)pEncoderContext->mCodecParams->FrameHeight);

660 encoderMetadata->setInt32(kKeySliceHeight,

661 (int32_t)pEncoderContext->mCodecParams->FrameHeight);

662

663 switch( pEncoderContext->mCodecParams->FrameRate ) {

664 case M4ENCODER_k5_FPS: iFrameRate = 5; break;

665 case M4ENCODER_k7_5_FPS: iFrameRate = 8; break;

666 case M4ENCODER_k10_FPS: iFrameRate = 10; break;

667 case M4ENCODER_k12_5_FPS: iFrameRate = 13; break;

668 case M4ENCODER_k15_FPS: iFrameRate = 15; break;

669 case M4ENCODER_k20_FPS: iFrameRate = 20; break;

670 case M4ENCODER_k25_FPS: iFrameRate = 25; break;

671 case M4ENCODER_k30_FPS: iFrameRate = 30; break;

672 case M4ENCODER_kVARIABLE_FPS:

673 iFrameRate = 30;

674 ALOGI("Frame rate set to M4ENCODER_kVARIABLE_FPS: set to 30");

675 break;

676 case M4ENCODER_kUSE_TIMESCALE:

677 iFrameRate = 30;

678 ALOGI("Frame rate set to M4ENCODER_kUSE_TIMESCALE: set to 30");

679 break;

680

681 default:

682 VIDEOEDITOR_CHECK(!"VideoEncoder_open:incorrect framerate",

683 M4ERR_STATE);

684 break;

685 }

686 encoderMetadata->setInt32(kKeyFrameRate, iFrameRate);

687 encoderMetadata->setInt32(kKeyBitRate,

688 (int32_t)pEncoderContext->mCodecParams->Bitrate);

689 encoderMetadata->setInt32(kKeyIFramesInterval, 1);

690

691 encoderMetadata->setInt32(kKeyColorFormat,

692 pEncoderContext->mEncoderColorFormat);

693

694 if (pEncoderContext->mCodecParams->Format != M4ENCODER_kH263) {

695 // Get the encoder DSI

696 err = VideoEditorVideoEncoder_getDSI(pEncoderContext, encoderMetadata);

697 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

698 }

699

700 // Create the encoder source

701 pEncoderContext->mEncoderSource = VideoEditorVideoEncoderSource::Create(

702 encoderMetadata);

703 VIDEOEDITOR_CHECK(

704 NULL != pEncoderContext->mEncoderSource.get(), M4ERR_STATE);

705

706 // Connect to the OMX client

707 result = pEncoderContext->mClient.connect();

708 VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);

709

710 // Create the OMX codec

711 #ifdef VIDEOEDITOR_FORCECODEC

712 codecFlags |= OMXCodec::VIDEOEDITOR_FORCECODEC;

713 #endif /* VIDEOEDITOR_FORCECODEC */

714 pEncoderContext->mEncoder = OMXCodec::Create(

715 pEncoderContext->mClient.interface(), encoderMetadata, true,

716 pEncoderContext->mEncoderSource, NULL, codecFlags);

717 VIDEOEDITOR_CHECK(NULL != pEncoderContext->mEncoder.get(), M4ERR_STATE);

718 ALOGV("VideoEditorVideoEncoder_open : DONE");

719 pEncoderContext->mPuller = new MediaBufferPuller(

720 pEncoderContext->mEncoder);

721

722 // Set the new state

723 pEncoderContext->mState = OPENED;

724

725 cleanUp:

726 if( M4NO_ERROR == err ) {

727 ALOGV("VideoEditorVideoEncoder_open no error");

728 } else {

729 VideoEditorVideoEncoder_close(pEncoderContext);

730 ALOGV("VideoEditorVideoEncoder_open ERROR 0x%X", err);

731 }

732 ALOGV("VideoEditorVideoEncoder_open end");

733 return err;

734 }

735

736 M4OSA_ERR VideoEditorVideoEncoder_processInputBuffer(

737 M4ENCODER_Context pContext, M4OSA_Double Cts,

738 M4OSA_Bool bReachedEOS) {

739 M4OSA_ERR err = M4NO_ERROR;

740 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

741 M4VIFI_ImagePlane pOutPlane[3];

742 MediaBuffer* buffer = NULL;

743 int32_t nbBuffer = 0;

744

745 ALOGV("VideoEditorVideoEncoder_processInputBuffer begin: cts %f", Cts);

746 // Input parameters check

747 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

748

749 pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

750 pOutPlane[0].pac_data = M4OSA_NULL;

751 pOutPlane[1].pac_data = M4OSA_NULL;

752 pOutPlane[2].pac_data = M4OSA_NULL;

753

754 if ( M4OSA_FALSE == bReachedEOS ) {

755 M4OSA_UInt32 sizeY = pEncoderContext->mCodecParams->FrameWidth *

756 pEncoderContext->mCodecParams->FrameHeight;

757 M4OSA_UInt32 sizeU = sizeY >> 2;

758 M4OSA_UInt32 size = sizeY + 2*sizeU;

759 M4OSA_UInt8* pData = M4OSA_NULL;

760 buffer = new MediaBuffer((size_t)size);

761 pData = (M4OSA_UInt8*)buffer->data() + buffer->range_offset();

762

763 // Prepare the output image for pre-processing

764 pOutPlane[0].u_width = pEncoderContext->mCodecParams->FrameWidth;

765 pOutPlane[0].u_height = pEncoderContext->mCodecParams->FrameHeight;

766 pOutPlane[0].u_topleft = 0;

767 pOutPlane[0].u_stride = pOutPlane[0].u_width;

768 pOutPlane[1].u_width = pOutPlane[0].u_width/2;

769 pOutPlane[1].u_height = pOutPlane[0].u_height/2;

770 pOutPlane[1].u_topleft = 0;

771 pOutPlane[1].u_stride = pOutPlane[0].u_stride/2;

772 pOutPlane[2].u_width = pOutPlane[1].u_width;

773 pOutPlane[2].u_height = pOutPlane[1].u_height;

774 pOutPlane[2].u_topleft = 0;

775 pOutPlane[2].u_stride = pOutPlane[1].u_stride;

776

777 pOutPlane[0].pac_data = pData;

778 pOutPlane[1].pac_data = pData + sizeY;

779 pOutPlane[2].pac_data = pData + sizeY + sizeU;

780

781 // Apply pre-processing

782 err = pEncoderContext->mPreProcFunction(

783 pEncoderContext->mPreProcContext, M4OSA_NULL, pOutPlane);

784 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

785

786 // Convert MediaBuffer to the encoder input format if necessary

787 if (pEncoderContext->mI420ColorConverter) {

788 I420ColorConverter* converter = pEncoderContext->mI420ColorConverter;

789 int actualWidth = pEncoderContext->mCodecParams->FrameWidth;

790 int actualHeight = pEncoderContext->mCodecParams->FrameHeight;

791

792 int encoderWidth, encoderHeight;

793 ARect encoderRect;

794 int encoderBufferSize;

795

796 if (converter->getEncoderInputBufferInfo(

797 actualWidth, actualHeight,

798 &encoderWidth, &encoderHeight,

799 &encoderRect, &encoderBufferSize) == 0) {

800

801 MediaBuffer* newBuffer = new MediaBuffer(encoderBufferSize);

802

803 if (converter->convertI420ToEncoderInput(

804 pData, // srcBits

805 actualWidth, actualHeight,

806 encoderWidth, encoderHeight,

807 encoderRect,

808 (uint8_t*)newBuffer->data() + newBuffer->range_offset()) < 0) {

809 ALOGE("convertI420ToEncoderInput failed");

810 }

811

812 // switch to new buffer

813 buffer->release();

814 buffer = newBuffer;

815 }

816 }

817

818 // Set the metadata

819 buffer->meta_data()->setInt64(kKeyTime, (int64_t)(Cts*1000));

820 }

821

822 // Push the buffer to the source, a NULL buffer, notifies the source of EOS

823 nbBuffer = pEncoderContext->mEncoderSource->storeBuffer(buffer);

824

825 cleanUp:

826 if ( M4NO_ERROR == err ) {

827 ALOGV("VideoEditorVideoEncoder_processInputBuffer error 0x%X", err);

828 } else {

829 if( NULL != buffer ) {

830 buffer->release();

831 }

832 ALOGV("VideoEditorVideoEncoder_processInputBuffer ERROR 0x%X", err);

833 }

834 ALOGV("VideoEditorVideoEncoder_processInputBuffer end");

835 return err;

836 }

837

838 M4OSA_ERR VideoEditorVideoEncoder_processOutputBuffer(

839 M4ENCODER_Context pContext, MediaBuffer* buffer) {

840 M4OSA_ERR err = M4NO_ERROR;

841 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

842 M4OSA_UInt32 Cts = 0;

843 int32_t i32Tmp = 0;

844 int64_t i64Tmp = 0;

845 status_t result = OK;

846

847 ALOGV("VideoEditorVideoEncoder_processOutputBuffer begin");

848 // Input parameters check

849 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

850 VIDEOEDITOR_CHECK(M4OSA_NULL != buffer, M4ERR_PARAMETER);

851

852 pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

853

854 // Process the returned AU

855 if ( 0 == buffer->range_length() ) {

856 // Encoder has no data yet, nothing unusual

857 ALOGV("VideoEditorVideoEncoder_processOutputBuffer : buffer is empty");

858 goto cleanUp;

859 }

860 VIDEOEDITOR_CHECK(0 == ((M4OSA_UInt32)buffer->data())%4, M4ERR_PARAMETER);

861 VIDEOEDITOR_CHECK(buffer->meta_data().get(), M4ERR_PARAMETER);

862 if ( buffer->meta_data()->findInt32(kKeyIsCodecConfig, &i32Tmp) && i32Tmp ){

863 { // Display the DSI

864 ALOGV("VideoEditorVideoEncoder_processOutputBuffer DSI %d",

865 buffer->range_length());

866 uint8_t* tmp = (uint8_t*)(buffer->data());

867 for( uint32_t i=0; i<buffer->range_length(); i++ ) {

868 ALOGV("DSI [%d] %.2X", i, tmp[i]);

869 }

870 }

871 } else {

872 // Check the CTS

873 VIDEOEDITOR_CHECK(buffer->meta_data()->findInt64(kKeyTime, &i64Tmp),

874 M4ERR_STATE);

875

876 pEncoderContext->mNbOutputFrames++;

877 if ( 0 > pEncoderContext->mFirstOutputCts ) {

878 pEncoderContext->mFirstOutputCts = i64Tmp;

879 }

880 pEncoderContext->mLastOutputCts = i64Tmp;

881

882 Cts = (M4OSA_Int32)(i64Tmp/1000);

883 ALOGV("[TS_CHECK] VI/ENC WRITE frame %d @ %lld -> %d (last %d)",

884 pEncoderContext->mNbOutputFrames, i64Tmp, Cts,

885 pEncoderContext->mLastCTS);

886 if ( Cts < pEncoderContext->mLastCTS ) {

887 ALOGV("VideoEncoder_processOutputBuffer WARNING : Cts is going "

888 "backwards %d < %d", Cts, pEncoderContext->mLastCTS);

889 goto cleanUp;

890 }

891 ALOGV("VideoEditorVideoEncoder_processOutputBuffer : %d %d",

892 Cts, pEncoderContext->mLastCTS);

893

894 // Retrieve the AU container

895 err = pEncoderContext->mWriterDataInterface->pStartAU(

896 pEncoderContext->mWriterDataInterface->pWriterContext,

897 pEncoderContext->mAccessUnit->stream->streamID,

898 pEncoderContext->mAccessUnit);

899 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

900

901 // Format the AU

902 VIDEOEDITOR_CHECK(

903 buffer->range_length() <= pEncoderContext->mAccessUnit->size,

904 M4ERR_PARAMETER);

905 // Remove H264 AU start code

906 if ( M4ENCODER_kH264 == pEncoderContext->mFormat ) {

907 if (!memcmp((const uint8_t *)buffer->data() + \

908 buffer->range_offset(), "\x00\x00\x00\x01", 4) ) {

909 buffer->set_range(buffer->range_offset() + 4,

910 buffer->range_length() - 4);

911 }

912 }

913

914 if ( (M4ENCODER_kH264 == pEncoderContext->mFormat) &&

915 (M4OSA_NULL != pEncoderContext->mH264NALUPostProcessFct) ) {

916 // H264 trimming case, NALU post processing is needed

917 M4OSA_Int32 outputSize = pEncoderContext->mAccessUnit->size;

918 err = pEncoderContext->mH264NALUPostProcessFct(

919 pEncoderContext->mH264NALUPostProcessCtx,

920 (M4OSA_UInt8*)buffer->data()+buffer->range_offset(),

921 buffer->range_length(),

922 (M4OSA_UInt8*)pEncoderContext->mAccessUnit->dataAddress,

923 &outputSize);

924 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

925 pEncoderContext->mAccessUnit->size = (M4OSA_UInt32)outputSize;

926 } else {

927 // The AU can just be copied

928 memcpy((void *)pEncoderContext->mAccessUnit->\

929 dataAddress, (void *)((M4OSA_MemAddr8)(buffer->data())+buffer->\

930 range_offset()), buffer->range_length());

931 pEncoderContext->mAccessUnit->size =

932 (M4OSA_UInt32)buffer->range_length();

933 }

934

935 if ( buffer->meta_data()->findInt32(kKeyIsSyncFrame,&i32Tmp) && i32Tmp){

936 pEncoderContext->mAccessUnit->attribute = AU_RAP;

937 } else {

938 pEncoderContext->mAccessUnit->attribute = AU_P_Frame;

939 }

940 pEncoderContext->mLastCTS = Cts;

941 pEncoderContext->mAccessUnit->CTS = Cts;

942 pEncoderContext->mAccessUnit->DTS = Cts;

943

944 ALOGV("VideoEditorVideoEncoder_processOutputBuffer: AU @ 0x%X 0x%X %d %d",

945 pEncoderContext->mAccessUnit->dataAddress,

946 *pEncoderContext->mAccessUnit->dataAddress,

947 pEncoderContext->mAccessUnit->size,

948 pEncoderContext->mAccessUnit->CTS);

949

950 // Write the AU

951 err = pEncoderContext->mWriterDataInterface->pProcessAU(

952 pEncoderContext->mWriterDataInterface->pWriterContext,

953 pEncoderContext->mAccessUnit->stream->streamID,

954 pEncoderContext->mAccessUnit);

955 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

956 }

957

958 cleanUp:

959 if( M4NO_ERROR == err ) {

960 ALOGV("VideoEditorVideoEncoder_processOutputBuffer no error");

961 } else {

962 SAFE_FREE(pEncoderContext->mHeader.pBuf);

963 pEncoderContext->mHeader.Size = 0;

964 ALOGV("VideoEditorVideoEncoder_processOutputBuffer ERROR 0x%X", err);

965 }

966 ALOGV("VideoEditorVideoEncoder_processOutputBuffer end");

967 return err;

968 }

969

970 M4OSA_ERR VideoEditorVideoEncoder_encode(M4ENCODER_Context pContext,

971 M4VIFI_ImagePlane* pInPlane, M4OSA_Double Cts,

972 M4ENCODER_FrameMode FrameMode) {

973 M4OSA_ERR err = M4NO_ERROR;

974 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

975 status_t result = OK;

976 MediaBuffer* outputBuffer = NULL;

977

978 ALOGV("VideoEditorVideoEncoder_encode 0x%X %f %d", pInPlane, Cts, FrameMode);

979 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

980

981 pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

982 if ( STARTED == pEncoderContext->mState ) {

983 pEncoderContext->mState = BUFFERING;

984 }

985 VIDEOEDITOR_CHECK(

986 (BUFFERING | READING) & pEncoderContext->mState, M4ERR_STATE);

987

988 pEncoderContext->mNbInputFrames++;

989 if ( 0 > pEncoderContext->mFirstInputCts ) {

990 pEncoderContext->mFirstInputCts = Cts;

991 }

992 pEncoderContext->mLastInputCts = Cts;

993

994 ALOGV("VideoEditorVideoEncoder_encode 0x%X %d %f (%d)", pInPlane, FrameMode,

995 Cts, pEncoderContext->mLastCTS);

996

997 // Push the input buffer to the encoder source

998 err = VideoEditorVideoEncoder_processInputBuffer(pEncoderContext, Cts,

999 M4OSA_FALSE);

1000 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

1001

1002 // Notify the source in case of EOS

1003 if ( M4ENCODER_kLastFrame == FrameMode ) {

1004 err = VideoEditorVideoEncoder_processInputBuffer(

1005 pEncoderContext, 0, M4OSA_TRUE);

1006 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

1007 }

1008

1009 if ( BUFFERING == pEncoderContext->mState ) {

1010 // Prefetch is complete, start reading

1011 pEncoderContext->mState = READING;

1012 }

1013 // Read

1014 while (1) {

1015 MediaBuffer *outputBuffer =

1016 pEncoderContext->mPuller->getBufferNonBlocking();

1017

1018 if (outputBuffer == NULL) {

1019 int32_t YUVBufferNumber =

1020 pEncoderContext->mEncoderSource->getNumberOfBuffersInQueue();

1021 /* Make sure that the configured maximum number of prefetch YUV frames is

1022 * not exceeded. This is to limit the amount of memory usage of video editor engine.

1023 * The value of maximum prefetch Yuv frames is defined in media_profiles.xml */

1024 if ((YUVBufferNumber < pEncoderContext->mMaxPrefetchFrames) ||

1025 (pEncoderContext->mPuller->hasMediaSourceReturnedError()

1026 == true)) {

1027 break;

1028 }

1029 } else {

1030 // Provide the encoded AU to the writer

1031 err = VideoEditorVideoEncoder_processOutputBuffer(pEncoderContext,

1032 outputBuffer);

1033 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

1034

1035 pEncoderContext->mPuller->putBuffer(outputBuffer);

1036 }

1037 }

1038

1039 cleanUp:

1040 if( M4NO_ERROR == err ) {

1041 ALOGV("VideoEditorVideoEncoder_encode no error");

1042 } else {

1043 ALOGV("VideoEditorVideoEncoder_encode ERROR 0x%X", err);

1044 }

1045 ALOGV("VideoEditorVideoEncoder_encode end");

1046 return err;

1047 }

1048

1049 M4OSA_ERR VideoEditorVideoEncoder_start(M4ENCODER_Context pContext) {

1050 M4OSA_ERR err = M4NO_ERROR;

1051 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

1052 status_t result = OK;

1053

1054 ALOGV("VideoEditorVideoEncoder_start begin");

1055 // Input parameters check

1056 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

1057

1058 pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

1059 VIDEOEDITOR_CHECK(OPENED == pEncoderContext->mState, M4ERR_STATE);

1060

1061 pEncoderContext->mNbInputFrames = 0;

1062 pEncoderContext->mFirstInputCts = -1.0;

1063 pEncoderContext->mLastInputCts = -1.0;

1064 pEncoderContext->mNbOutputFrames = 0;

1065 pEncoderContext->mFirstOutputCts = -1;

1066 pEncoderContext->mLastOutputCts = -1;

1067

1068 result = pEncoderContext->mEncoder->start();

1069 VIDEOEDITOR_CHECK(OK == result, M4ERR_STATE);

1070

1071 pEncoderContext->mPuller->start();

1072

1073 // Set the new state

1074 pEncoderContext->mState = STARTED;

1075

1076 cleanUp:

1077 if ( M4NO_ERROR == err ) {

1078 ALOGV("VideoEditorVideoEncoder_start no error");

1079 } else {

1080 ALOGV("VideoEditorVideoEncoder_start ERROR 0x%X", err);

1081 }

1082 ALOGV("VideoEditorVideoEncoder_start end");

1083 return err;

1084 }

1085

1086 M4OSA_ERR VideoEditorVideoEncoder_stop(M4ENCODER_Context pContext) {

1087 M4OSA_ERR err = M4NO_ERROR;

1088 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

1089 MediaBuffer* outputBuffer = NULL;

1090 status_t result = OK;

1091

1092 ALOGV("VideoEditorVideoEncoder_stop begin");

1093 // Input parameters check

1094 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

1095 pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

1096

1097 // Send EOS again to make sure the source doesn't block.

1098 err = VideoEditorVideoEncoder_processInputBuffer(pEncoderContext, 0,

1099 M4OSA_TRUE);

1100 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

1101

1102 // Process the remaining buffers if necessary

1103 if ( (BUFFERING | READING) & pEncoderContext->mState ) {

1104 while (1) {

1105 MediaBuffer *outputBuffer =

1106 pEncoderContext->mPuller->getBufferBlocking();

1107

1108 if (outputBuffer == NULL) break;

1109

1110 err = VideoEditorVideoEncoder_processOutputBuffer(

1111 pEncoderContext, outputBuffer);

1112 VIDEOEDITOR_CHECK(M4NO_ERROR == err, err);

1113

1114 pEncoderContext->mPuller->putBuffer(outputBuffer);

1115 }

1116

1117 pEncoderContext->mState = STARTED;

1118 }

1119

1120 // Stop the graph module if necessary

1121 if ( STARTED == pEncoderContext->mState ) {

1122 pEncoderContext->mPuller->stop();

1123 pEncoderContext->mEncoder->stop();

1124 pEncoderContext->mState = OPENED;

1125 }

1126

1127 if (pEncoderContext->mNbInputFrames != pEncoderContext->mNbOutputFrames) {

1128 ALOGW("Some frames were not encoded: input(%d) != output(%d)",

1129 pEncoderContext->mNbInputFrames, pEncoderContext->mNbOutputFrames);

1130 }

1131

1132 cleanUp:

1133 if ( M4NO_ERROR == err ) {

1134 ALOGV("VideoEditorVideoEncoder_stop no error");

1135 } else {

1136 ALOGV("VideoEditorVideoEncoder_stop ERROR 0x%X", err);

1137 }

1138 ALOGV("VideoEditorVideoEncoder_stop end");

1139 return err;

1140 }

1141

1142 M4OSA_ERR VideoEditorVideoEncoder_regulBitRate(M4ENCODER_Context pContext) {

1143 ALOGW("regulBitRate is not implemented");

1144 return M4NO_ERROR;

1145 }

1146

1147 M4OSA_ERR VideoEditorVideoEncoder_setOption(M4ENCODER_Context pContext,

1148 M4OSA_UInt32 optionID, M4OSA_DataOption optionValue) {

1149 M4OSA_ERR err = M4NO_ERROR;

1150 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

1151

1152 ALOGV("VideoEditorVideoEncoder_setOption start optionID 0x%X", optionID);

1153 // Input parameters check

1154 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

1155

1156 pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

1157

1158 switch( optionID ) {

1159 case M4ENCODER_kOptionID_SetH264ProcessNALUfctsPtr:

1160 pEncoderContext->mH264NALUPostProcessFct =

1161 (H264MCS_ProcessEncodedNALU_fct*)optionValue;

1162 break;

1163 case M4ENCODER_kOptionID_H264ProcessNALUContext:

1164 pEncoderContext->mH264NALUPostProcessCtx =

1165 (M4OSA_Context)optionValue;

1166 break;

1167 default:

1168 ALOGV("VideoEditorVideoEncoder_setOption: unsupported optionId 0x%X",

1169 optionID);

1170 VIDEOEDITOR_CHECK(M4OSA_FALSE, M4ERR_BAD_OPTION_ID);

1171 break;

1172 }

1173

1174 cleanUp:

1175 if ( M4NO_ERROR == err ) {

1176 ALOGV("VideoEditorVideoEncoder_setOption no error");

1177 } else {

1178 ALOGV("VideoEditorVideoEncoder_setOption ERROR 0x%X", err);

1179 }

1180 ALOGV("VideoEditorVideoEncoder_setOption end");

1181 return err;

1182 }

1183

1184 M4OSA_ERR VideoEditorVideoEncoder_getOption(M4ENCODER_Context pContext,

1185 M4OSA_UInt32 optionID, M4OSA_DataOption optionValue) {

1186 M4OSA_ERR err = M4NO_ERROR;

1187 VideoEditorVideoEncoder_Context* pEncoderContext = M4OSA_NULL;

1188

1189 ALOGV("VideoEditorVideoEncoder_getOption begin optinId 0x%X", optionID);

1190 // Input parameters check

1191 VIDEOEDITOR_CHECK(M4OSA_NULL != pContext, M4ERR_PARAMETER);

1192 pEncoderContext = (VideoEditorVideoEncoder_Context*)pContext;

1193

1194 switch( optionID ) {

1195 case M4ENCODER_kOptionID_EncoderHeader:

1196 VIDEOEDITOR_CHECK(

1197 M4OSA_NULL != pEncoderContext->mHeader.pBuf, M4ERR_STATE);

1198 *(M4ENCODER_Header**)optionValue = &(pEncoderContext->mHeader);

1199 break;

1200 default:

1201 ALOGV("VideoEditorVideoEncoder_getOption: unsupported optionId 0x%X",

1202 optionID);

1203 VIDEOEDITOR_CHECK(M4OSA_FALSE, M4ERR_BAD_OPTION_ID);

1204 break;

1205 }

1206

1207 cleanUp:

1208 if ( M4NO_ERROR == err ) {

1209 ALOGV("VideoEditorVideoEncoder_getOption no error");

1210 } else {

1211 ALOGV("VideoEditorVideoEncoder_getOption ERROR 0x%X", err);

1212 }

1213 return err;

1214 }

1215

1216 M4OSA_ERR VideoEditorVideoEncoder_getInterface(M4ENCODER_Format format,

1217 M4ENCODER_Format* pFormat,

1218 M4ENCODER_GlobalInterface** pEncoderInterface, M4ENCODER_OpenMode mode){

1219 M4OSA_ERR err = M4NO_ERROR;

1220

1221 // Input parameters check

1222 VIDEOEDITOR_CHECK(M4OSA_NULL != pFormat, M4ERR_PARAMETER);

1223 VIDEOEDITOR_CHECK(M4OSA_NULL != pEncoderInterface, M4ERR_PARAMETER);

1224

1225 ALOGV("VideoEditorVideoEncoder_getInterface begin 0x%x 0x%x %d", pFormat,

1226 pEncoderInterface, mode);

1227

1228 SAFE_MALLOC(*pEncoderInterface, M4ENCODER_GlobalInterface, 1,

1229 "VideoEditorVideoEncoder");

1230

1231 *pFormat = format;

1232

1233 switch( format ) {

1234 case M4ENCODER_kH263:

1235 {

1236 (*pEncoderInterface)->pFctInit =

1237 VideoEditorVideoEncoder_init_H263;

1238 break;

1239 }

1240 case M4ENCODER_kMPEG4:

1241 {

1242 (*pEncoderInterface)->pFctInit =

1243 VideoEditorVideoEncoder_init_MPEG4;

1244 break;

1245 }

1246 case M4ENCODER_kH264:

1247 {

1248 (*pEncoderInterface)->pFctInit =

1249 VideoEditorVideoEncoder_init_H264;

1250 break;

1251 }

1252 default:

1253 ALOGV("VideoEditorVideoEncoder_getInterface : unsupported format %d",

1254 format);

1255 VIDEOEDITOR_CHECK(M4OSA_FALSE, M4ERR_PARAMETER);

1256 break;

1257 }

1258 (*pEncoderInterface)->pFctOpen = VideoEditorVideoEncoder_open;

1259 (*pEncoderInterface)->pFctStart = VideoEditorVideoEncoder_start;

1260 (*pEncoderInterface)->pFctStop = VideoEditorVideoEncoder_stop;

1261 (*pEncoderInterface)->pFctPause = M4OSA_NULL;

1262 (*pEncoderInterface)->pFctResume = M4OSA_NULL;

1263 (*pEncoderInterface)->pFctClose = VideoEditorVideoEncoder_close;

1264 (*pEncoderInterface)->pFctCleanup = VideoEditorVideoEncoder_cleanup;

1265 (*pEncoderInterface)->pFctRegulBitRate =

1266 VideoEditorVideoEncoder_regulBitRate;

1267 (*pEncoderInterface)->pFctEncode = VideoEditorVideoEncoder_encode;

1268 (*pEncoderInterface)->pFctSetOption = VideoEditorVideoEncoder_setOption;

1269 (*pEncoderInterface)->pFctGetOption = VideoEditorVideoEncoder_getOption;

1270

1271 cleanUp:

1272 if( M4NO_ERROR == err ) {

1273 ALOGV("VideoEditorVideoEncoder_getInterface no error");

1274 } else {

1275 *pEncoderInterface = M4OSA_NULL;

1276 ALOGV("VideoEditorVideoEncoder_getInterface ERROR 0x%X", err);

1277 }

1278 return err;

1279 }

1280

1281 extern "C" {

1282

1283 M4OSA_ERR VideoEditorVideoEncoder_getInterface_H263(M4ENCODER_Format* pFormat,

1284 M4ENCODER_GlobalInterface** pEncoderInterface, M4ENCODER_OpenMode mode){

1285 return VideoEditorVideoEncoder_getInterface(M4ENCODER_kH263, pFormat,

1286 pEncoderInterface, mode);

1287 }

1288

1289 M4OSA_ERR VideoEditorVideoEncoder_getInterface_MPEG4(M4ENCODER_Format* pFormat,

1290 M4ENCODER_GlobalInterface** pEncoderInterface, M4ENCODER_OpenMode mode){

1291 return VideoEditorVideoEncoder_getInterface(M4ENCODER_kMPEG4, pFormat,

1292 pEncoderInterface, mode);

1293 }

1294

1295 M4OSA_ERR VideoEditorVideoEncoder_getInterface_H264(M4ENCODER_Format* pFormat,

1296 M4ENCODER_GlobalInterface** pEncoderInterface, M4ENCODER_OpenMode mode){

1297 return VideoEditorVideoEncoder_getInterface(M4ENCODER_kH264, pFormat,

1298 pEncoderInterface, mode);

1299

1300 }

1301

1302 } // extern "C"

1303

1304 } // namespace android