-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathC2VDAComponent.cpp
1822 lines (1600 loc) · 75.2 KB
/
C2VDAComponent.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//#define LOG_NDEBUG 0
#define LOG_TAG "C2VDAComponent"
#ifdef V4L2_CODEC2_ARC
#include <C2VDAAdaptorProxy.h>
#else
#include <C2VDAAdaptor.h>
#endif
#define __C2_GENERATE_GLOBAL_VARS__
#include <C2VDAAllocatorStore.h>
#include <C2VDAComponent.h>
#include <C2VDAPixelFormat.h>
#include <C2VDASupport.h> // to getParamReflector from vda store
#include <C2VdaBqBlockPool.h>
#include <C2VdaPooledBlockPool.h>
#include <h264_parser.h>
#include <C2AllocatorGralloc.h>
#include <C2ComponentFactory.h>
#include <C2PlatformSupport.h>
#include <Codec2Mapper.h>
#include <base/bind.h>
#include <base/bind_helpers.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/foundation/ColorUtils.h>
#include <utils/Log.h>
#include <utils/misc.h>
#include <inttypes.h>
#include <string.h>
#include <algorithm>
#include <string>
#define UNUSED(expr) \
do { \
(void)(expr); \
} while (0)
namespace android {
namespace {
// Mask against 30 bits to avoid (undefined) wraparound on signed integer.
int32_t frameIndexToBitstreamId(c2_cntr64_t frameIndex) {
return static_cast<int32_t>(frameIndex.peeku() & 0x3FFFFFFF);
}
// Use basic graphic block pool/allocator as default.
const C2BlockPool::local_id_t kDefaultOutputBlockPool = C2BlockPool::BASIC_GRAPHIC;
const C2String kH264DecoderName = "c2.vda.avc.decoder";
const C2String kVP8DecoderName = "c2.vda.vp8.decoder";
const C2String kVP9DecoderName = "c2.vda.vp9.decoder";
const C2String kH264SecureDecoderName = "c2.vda.avc.decoder.secure";
const C2String kVP8SecureDecoderName = "c2.vda.vp8.decoder.secure";
const C2String kVP9SecureDecoderName = "c2.vda.vp9.decoder.secure";
const uint32_t kDpbOutputBufferExtraCount = 3; // Use the same number as ACodec.
const int kDequeueRetryDelayUs = 10000; // Wait time of dequeue buffer retry in microseconds.
const int32_t kAllocateBufferMaxRetries = 10; // Max retry time for fetchGraphicBlock timeout.
} // namespace
static c2_status_t adaptorResultToC2Status(VideoDecodeAcceleratorAdaptor::Result result) {
switch (result) {
case VideoDecodeAcceleratorAdaptor::Result::SUCCESS:
return C2_OK;
case VideoDecodeAcceleratorAdaptor::Result::ILLEGAL_STATE:
ALOGE("Got error: ILLEGAL_STATE");
return C2_BAD_STATE;
case VideoDecodeAcceleratorAdaptor::Result::INVALID_ARGUMENT:
ALOGE("Got error: INVALID_ARGUMENT");
return C2_BAD_VALUE;
case VideoDecodeAcceleratorAdaptor::Result::UNREADABLE_INPUT:
ALOGE("Got error: UNREADABLE_INPUT");
return C2_BAD_VALUE;
case VideoDecodeAcceleratorAdaptor::Result::PLATFORM_FAILURE:
ALOGE("Got error: PLATFORM_FAILURE");
return C2_CORRUPTED;
case VideoDecodeAcceleratorAdaptor::Result::INSUFFICIENT_RESOURCES:
ALOGE("Got error: INSUFFICIENT_RESOURCES");
return C2_NO_MEMORY;
default:
ALOGE("Unrecognizable adaptor result (value = %d)...", result);
return C2_CORRUPTED;
}
}
// static
C2R C2VDAComponent::IntfImpl::ProfileLevelSetter(bool mayBlock,
C2P<C2StreamProfileLevelInfo::input>& info) {
(void)mayBlock;
return info.F(info.v.profile)
.validatePossible(info.v.profile)
.plus(info.F(info.v.level).validatePossible(info.v.level));
}
// static
C2R C2VDAComponent::IntfImpl::SizeSetter(bool mayBlock,
C2P<C2StreamPictureSizeInfo::output>& videoSize) {
(void)mayBlock;
// TODO: maybe apply block limit?
return videoSize.F(videoSize.v.width)
.validatePossible(videoSize.v.width)
.plus(videoSize.F(videoSize.v.height).validatePossible(videoSize.v.height));
}
// static
template <typename T>
C2R C2VDAComponent::IntfImpl::DefaultColorAspectsSetter(bool mayBlock, C2P<T>& def) {
(void)mayBlock;
if (def.v.range > C2Color::RANGE_OTHER) {
def.set().range = C2Color::RANGE_OTHER;
}
if (def.v.primaries > C2Color::PRIMARIES_OTHER) {
def.set().primaries = C2Color::PRIMARIES_OTHER;
}
if (def.v.transfer > C2Color::TRANSFER_OTHER) {
def.set().transfer = C2Color::TRANSFER_OTHER;
}
if (def.v.matrix > C2Color::MATRIX_OTHER) {
def.set().matrix = C2Color::MATRIX_OTHER;
}
return C2R::Ok();
}
// static
C2R C2VDAComponent::IntfImpl::MergedColorAspectsSetter(
bool mayBlock, C2P<C2StreamColorAspectsInfo::output>& merged,
const C2P<C2StreamColorAspectsTuning::output>& def,
const C2P<C2StreamColorAspectsInfo::input>& coded) {
(void)mayBlock;
// Take coded values for all specified fields, and default values for unspecified ones.
merged.set().range = coded.v.range == RANGE_UNSPECIFIED ? def.v.range : coded.v.range;
merged.set().primaries =
coded.v.primaries == PRIMARIES_UNSPECIFIED ? def.v.primaries : coded.v.primaries;
merged.set().transfer =
coded.v.transfer == TRANSFER_UNSPECIFIED ? def.v.transfer : coded.v.transfer;
merged.set().matrix = coded.v.matrix == MATRIX_UNSPECIFIED ? def.v.matrix : coded.v.matrix;
return C2R::Ok();
}
C2VDAComponent::IntfImpl::IntfImpl(C2String name, const std::shared_ptr<C2ReflectorHelper>& helper)
: C2InterfaceHelper(helper), mInitStatus(C2_OK) {
setDerivedInstance(this);
// TODO(johnylin): use factory function to determine whether V4L2 stream or slice API is.
char inputMime[128];
if (name == kH264DecoderName || name == kH264SecureDecoderName) {
strcpy(inputMime, MEDIA_MIMETYPE_VIDEO_AVC);
mInputCodec = InputCodec::H264;
addParameter(
DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL)
.withDefault(new C2StreamProfileLevelInfo::input(
0u, C2Config::PROFILE_AVC_MAIN, C2Config::LEVEL_AVC_4))
.withFields(
{C2F(mProfileLevel, profile)
.oneOf({C2Config::PROFILE_AVC_BASELINE,
C2Config::PROFILE_AVC_CONSTRAINED_BASELINE,
C2Config::PROFILE_AVC_MAIN,
C2Config::PROFILE_AVC_HIGH,
C2Config::PROFILE_AVC_CONSTRAINED_HIGH}),
C2F(mProfileLevel, level)
.oneOf({C2Config::LEVEL_AVC_1, C2Config::LEVEL_AVC_1B,
C2Config::LEVEL_AVC_1_1, C2Config::LEVEL_AVC_1_2,
C2Config::LEVEL_AVC_1_3, C2Config::LEVEL_AVC_2,
C2Config::LEVEL_AVC_2_1, C2Config::LEVEL_AVC_2_2,
C2Config::LEVEL_AVC_3, C2Config::LEVEL_AVC_3_1,
C2Config::LEVEL_AVC_3_2, C2Config::LEVEL_AVC_4,
C2Config::LEVEL_AVC_4_1, C2Config::LEVEL_AVC_4_2,
C2Config::LEVEL_AVC_5, C2Config::LEVEL_AVC_5_1,
C2Config::LEVEL_AVC_5_2})})
.withSetter(ProfileLevelSetter)
.build());
} else if (name == kVP8DecoderName || name == kVP8SecureDecoderName) {
strcpy(inputMime, MEDIA_MIMETYPE_VIDEO_VP8);
mInputCodec = InputCodec::VP8;
addParameter(DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL)
.withConstValue(new C2StreamProfileLevelInfo::input(
0u, C2Config::PROFILE_UNUSED, C2Config::LEVEL_UNUSED))
.build());
} else if (name == kVP9DecoderName || name == kVP9SecureDecoderName) {
strcpy(inputMime, MEDIA_MIMETYPE_VIDEO_VP9);
mInputCodec = InputCodec::VP9;
addParameter(
DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL)
.withDefault(new C2StreamProfileLevelInfo::input(
0u, C2Config::PROFILE_VP9_0, C2Config::LEVEL_VP9_5))
.withFields({C2F(mProfileLevel, profile).oneOf({C2Config::PROFILE_VP9_0}),
C2F(mProfileLevel, level)
.oneOf({C2Config::LEVEL_VP9_1, C2Config::LEVEL_VP9_1_1,
C2Config::LEVEL_VP9_2, C2Config::LEVEL_VP9_2_1,
C2Config::LEVEL_VP9_3, C2Config::LEVEL_VP9_3_1,
C2Config::LEVEL_VP9_4, C2Config::LEVEL_VP9_4_1,
C2Config::LEVEL_VP9_5})})
.withSetter(ProfileLevelSetter)
.build());
} else {
ALOGE("Invalid component name: %s", name.c_str());
mInitStatus = C2_BAD_VALUE;
return;
}
// Get supported profiles from VDA.
// TODO: re-think the suitable method of getting supported profiles for both pure Android and
// ARC++.
media::VideoDecodeAccelerator::SupportedProfiles supportedProfiles;
#ifdef V4L2_CODEC2_ARC
supportedProfiles = arc::C2VDAAdaptorProxy::GetSupportedProfiles(mInputCodec);
#else
supportedProfiles = C2VDAAdaptor::GetSupportedProfiles(mInputCodec);
#endif
if (supportedProfiles.empty()) {
ALOGE("No supported profile from input codec: %d", mInputCodec);
mInitStatus = C2_BAD_VALUE;
return;
}
mCodecProfile = supportedProfiles[0].profile;
auto minSize = supportedProfiles[0].min_resolution;
auto maxSize = supportedProfiles[0].max_resolution;
addParameter(
DefineParam(mInputFormat, C2_PARAMKEY_INPUT_STREAM_BUFFER_TYPE)
.withConstValue(new C2StreamBufferTypeSetting::input(0u, C2FormatCompressed))
.build());
addParameter(DefineParam(mOutputFormat, C2_PARAMKEY_OUTPUT_STREAM_BUFFER_TYPE)
.withConstValue(new C2StreamBufferTypeSetting::output(0u, C2FormatVideo))
.build());
addParameter(
DefineParam(mInputMediaType, C2_PARAMKEY_INPUT_MEDIA_TYPE)
.withConstValue(AllocSharedString<C2PortMediaTypeSetting::input>(inputMime))
.build());
addParameter(DefineParam(mOutputMediaType, C2_PARAMKEY_OUTPUT_MEDIA_TYPE)
.withConstValue(AllocSharedString<C2PortMediaTypeSetting::output>(
MEDIA_MIMETYPE_VIDEO_RAW))
.build());
addParameter(DefineParam(mSize, C2_PARAMKEY_STREAM_PICTURE_SIZE)
.withDefault(new C2StreamPictureSizeInfo::output(0u, 176, 144))
.withFields({
C2F(mSize, width).inRange(minSize.width(), maxSize.width(), 16),
C2F(mSize, height).inRange(minSize.height(), maxSize.height(), 16),
})
.withSetter(SizeSetter)
.build());
// App may set a smaller value for maximum of input buffer size than actually required
// by mistake. C2VDAComponent overrides it if the value specified by app is smaller than
// the calculated value in MaxSizeCalculator().
// This value is the default maximum of linear buffer size (kLinearBufferSize) in
// CCodecBufferChannel.cpp.
constexpr static size_t kLinearBufferSize = 1048576;
struct LocalCalculator {
static C2R MaxSizeCalculator(bool mayBlock, C2P<C2StreamMaxBufferSizeInfo::input>& me,
const C2P<C2StreamPictureSizeInfo::output>& size) {
(void)mayBlock;
// TODO: Need larger size?
me.set().value = kLinearBufferSize;
const uint32_t width = size.v.width;
const uint32_t height = size.v.height;
// Enlarge the input buffer for 4k video
if ((width > 1920 && height > 1080)) {
me.set().value = 4 * kLinearBufferSize;
}
return C2R::Ok();
}
};
addParameter(DefineParam(mMaxInputSize, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE)
.withDefault(new C2StreamMaxBufferSizeInfo::input(0u, kLinearBufferSize))
.withFields({
C2F(mMaxInputSize, value).any(),
})
.calculatedAs(LocalCalculator::MaxSizeCalculator, mSize)
.build());
bool secureMode = name.find(".secure") != std::string::npos;
C2Allocator::id_t inputAllocators[] = {secureMode ? C2VDAAllocatorStore::SECURE_LINEAR
: C2PlatformAllocatorStore::ION};
C2Allocator::id_t outputAllocators[] = {C2VDAAllocatorStore::V4L2_BUFFERPOOL};
C2Allocator::id_t surfaceAllocator = secureMode ? C2VDAAllocatorStore::SECURE_GRAPHIC
: C2VDAAllocatorStore::V4L2_BUFFERQUEUE;
addParameter(
DefineParam(mInputAllocatorIds, C2_PARAMKEY_INPUT_ALLOCATORS)
.withConstValue(C2PortAllocatorsTuning::input::AllocShared(inputAllocators))
.build());
addParameter(
DefineParam(mOutputAllocatorIds, C2_PARAMKEY_OUTPUT_ALLOCATORS)
.withConstValue(C2PortAllocatorsTuning::output::AllocShared(outputAllocators))
.build());
addParameter(DefineParam(mOutputSurfaceAllocatorId, C2_PARAMKEY_OUTPUT_SURFACE_ALLOCATOR)
.withConstValue(new C2PortSurfaceAllocatorTuning::output(surfaceAllocator))
.build());
C2BlockPool::local_id_t outputBlockPools[] = {kDefaultOutputBlockPool};
addParameter(
DefineParam(mOutputBlockPoolIds, C2_PARAMKEY_OUTPUT_BLOCK_POOLS)
.withDefault(C2PortBlockPoolsTuning::output::AllocShared(outputBlockPools))
.withFields({C2F(mOutputBlockPoolIds, m.values[0]).any(),
C2F(mOutputBlockPoolIds, m.values).inRange(0, 1)})
.withSetter(Setter<C2PortBlockPoolsTuning::output>::NonStrictValuesWithNoDeps)
.build());
addParameter(
DefineParam(mDefaultColorAspects, C2_PARAMKEY_DEFAULT_COLOR_ASPECTS)
.withDefault(new C2StreamColorAspectsTuning::output(
0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED,
C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
.withFields(
{C2F(mDefaultColorAspects, range)
.inRange(C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
C2F(mDefaultColorAspects, primaries)
.inRange(C2Color::PRIMARIES_UNSPECIFIED,
C2Color::PRIMARIES_OTHER),
C2F(mDefaultColorAspects, transfer)
.inRange(C2Color::TRANSFER_UNSPECIFIED,
C2Color::TRANSFER_OTHER),
C2F(mDefaultColorAspects, matrix)
.inRange(C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)})
.withSetter(DefaultColorAspectsSetter)
.build());
addParameter(
DefineParam(mCodedColorAspects, C2_PARAMKEY_VUI_COLOR_ASPECTS)
.withDefault(new C2StreamColorAspectsInfo::input(
0u, C2Color::RANGE_LIMITED, C2Color::PRIMARIES_UNSPECIFIED,
C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
.withFields(
{C2F(mCodedColorAspects, range)
.inRange(C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
C2F(mCodedColorAspects, primaries)
.inRange(C2Color::PRIMARIES_UNSPECIFIED,
C2Color::PRIMARIES_OTHER),
C2F(mCodedColorAspects, transfer)
.inRange(C2Color::TRANSFER_UNSPECIFIED,
C2Color::TRANSFER_OTHER),
C2F(mCodedColorAspects, matrix)
.inRange(C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)})
.withSetter(DefaultColorAspectsSetter)
.build());
addParameter(
DefineParam(mColorAspects, C2_PARAMKEY_COLOR_ASPECTS)
.withDefault(new C2StreamColorAspectsInfo::output(
0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED,
C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
.withFields(
{C2F(mColorAspects, range)
.inRange(C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
C2F(mColorAspects, primaries)
.inRange(C2Color::PRIMARIES_UNSPECIFIED,
C2Color::PRIMARIES_OTHER),
C2F(mColorAspects, transfer)
.inRange(C2Color::TRANSFER_UNSPECIFIED,
C2Color::TRANSFER_OTHER),
C2F(mColorAspects, matrix)
.inRange(C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)})
.withSetter(MergedColorAspectsSetter, mDefaultColorAspects, mCodedColorAspects)
.build());
}
////////////////////////////////////////////////////////////////////////////////
#define EXPECT_STATE_OR_RETURN_ON_ERROR(x) \
do { \
if (mComponentState == ComponentState::ERROR) return; \
CHECK_EQ(mComponentState, ComponentState::x); \
} while (0)
#define EXPECT_RUNNING_OR_RETURN_ON_ERROR() \
do { \
if (mComponentState == ComponentState::ERROR) return; \
CHECK_NE(mComponentState, ComponentState::UNINITIALIZED); \
} while (0)
C2VDAComponent::VideoFormat::VideoFormat(HalPixelFormat pixelFormat, uint32_t minNumBuffers,
media::Size codedSize, media::Rect visibleRect)
: mPixelFormat(pixelFormat),
mMinNumBuffers(minNumBuffers),
mCodedSize(codedSize),
mVisibleRect(visibleRect) {}
C2VDAComponent::C2VDAComponent(C2String name, c2_node_id_t id,
const std::shared_ptr<C2ReflectorHelper>& helper)
: mIntfImpl(std::make_shared<IntfImpl>(name, helper)),
mIntf(std::make_shared<SimpleInterface<IntfImpl>>(name.c_str(), id, mIntfImpl)),
mThread("C2VDAComponentThread"),
mDequeueThread("C2VDAComponentDequeueThread"),
mVDAInitResult(VideoDecodeAcceleratorAdaptor::Result::ILLEGAL_STATE),
mComponentState(ComponentState::UNINITIALIZED),
mPendingOutputEOS(false),
mPendingColorAspectsChange(false),
mPendingColorAspectsChangeFrameIndex(0),
mCodecProfile(media::VIDEO_CODEC_PROFILE_UNKNOWN),
mState(State::UNLOADED),
mWeakThisFactory(this) {
// TODO(johnylin): the client may need to know if init is failed.
if (mIntfImpl->status() != C2_OK) {
ALOGE("Component interface init failed (err code = %d)", mIntfImpl->status());
return;
}
mSecureMode = name.find(".secure") != std::string::npos;
if (!mThread.Start()) {
ALOGE("Component thread failed to start.");
return;
}
mTaskRunner = mThread.task_runner();
mState.store(State::LOADED);
}
C2VDAComponent::~C2VDAComponent() {
if (mThread.IsRunning()) {
mTaskRunner->PostTask(FROM_HERE,
::base::Bind(&C2VDAComponent::onDestroy, ::base::Unretained(this)));
mThread.Stop();
}
}
void C2VDAComponent::onDestroy() {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onDestroy");
if (mVDAAdaptor.get()) {
mVDAAdaptor->destroy();
mVDAAdaptor.reset(nullptr);
}
stopDequeueThread();
}
void C2VDAComponent::onStart(media::VideoCodecProfile profile, ::base::WaitableEvent* done) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onStart");
CHECK_EQ(mComponentState, ComponentState::UNINITIALIZED);
#ifdef V4L2_CODEC2_ARC
mVDAAdaptor.reset(new arc::C2VDAAdaptorProxy());
#else
mVDAAdaptor.reset(new C2VDAAdaptor());
#endif
mVDAInitResult = mVDAAdaptor->initialize(profile, mSecureMode, this);
if (mVDAInitResult == VideoDecodeAcceleratorAdaptor::Result::SUCCESS) {
mComponentState = ComponentState::STARTED;
}
if (!mSecureMode && mIntfImpl->getInputCodec() == InputCodec::H264) {
// Get default color aspects on start.
updateColorAspects();
mPendingColorAspectsChange = false;
}
done->Signal();
}
void C2VDAComponent::onQueueWork(std::unique_ptr<C2Work> work) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onQueueWork: flags=0x%x, index=%llu, timestamp=%llu", work->input.flags,
work->input.ordinal.frameIndex.peekull(), work->input.ordinal.timestamp.peekull());
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
uint32_t drainMode = NO_DRAIN;
if (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) {
drainMode = DRAIN_COMPONENT_WITH_EOS;
}
mQueue.push({std::move(work), drainMode});
// TODO(johnylin): set a maximum size of mQueue and check if mQueue is already full.
mTaskRunner->PostTask(FROM_HERE,
::base::Bind(&C2VDAComponent::onDequeueWork, ::base::Unretained(this)));
}
void C2VDAComponent::onDequeueWork() {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onDequeueWork");
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
if (mQueue.empty()) {
return;
}
if (mComponentState == ComponentState::DRAINING ||
mComponentState == ComponentState::FLUSHING) {
ALOGV("Temporarily stop dequeueing works since component is draining/flushing.");
return;
}
if (mComponentState != ComponentState::STARTED) {
ALOGE("Work queue should be empty if the component is not in STARTED state.");
return;
}
// Dequeue a work from mQueue.
std::unique_ptr<C2Work> work(std::move(mQueue.front().mWork));
auto drainMode = mQueue.front().mDrainMode;
mQueue.pop();
CHECK_LE(work->input.buffers.size(), 1u);
bool isEmptyCSDWork = false;
// Use frameIndex as bitstreamId.
int32_t bitstreamId = frameIndexToBitstreamId(work->input.ordinal.frameIndex);
if (work->input.buffers.empty()) {
// Client may queue a work with no input buffer for either it's EOS or empty CSD, otherwise
// every work must have one input buffer.
isEmptyCSDWork = work->input.flags & C2FrameData::FLAG_CODEC_CONFIG;
CHECK(drainMode != NO_DRAIN || isEmptyCSDWork);
// Emplace a nullptr to unify the check for work done.
ALOGV("Got a work with no input buffer! Emplace a nullptr inside.");
work->input.buffers.emplace_back(nullptr);
} else {
// If input.buffers is not empty, the buffer should have meaningful content inside.
C2ConstLinearBlock linearBlock = work->input.buffers.front()->data().linearBlocks().front();
CHECK_GT(linearBlock.size(), 0u);
// Call parseCodedColorAspects() to try to parse color aspects from bitstream only if:
// 1) This is non-secure decoding.
// 2) This is H264 codec.
// 3) This input is CSD buffer (with flags FLAG_CODEC_CONFIG).
if (!mSecureMode && (mIntfImpl->getInputCodec() == InputCodec::H264) &&
(work->input.flags & C2FrameData::FLAG_CODEC_CONFIG)) {
if (parseCodedColorAspects(linearBlock)) {
// Record current frame index, color aspects should be updated only for output
// buffers whose frame indices are not less than this one.
mPendingColorAspectsChange = true;
mPendingColorAspectsChangeFrameIndex = work->input.ordinal.frameIndex.peeku();
}
}
// Send input buffer to VDA for decode.
sendInputBufferToAccelerator(linearBlock, bitstreamId);
}
CHECK_EQ(work->worklets.size(), 1u);
work->worklets.front()->output.flags = static_cast<C2FrameData::flags_t>(0);
work->worklets.front()->output.buffers.clear();
work->worklets.front()->output.ordinal = work->input.ordinal;
if (drainMode != NO_DRAIN) {
mVDAAdaptor->flush();
mComponentState = ComponentState::DRAINING;
mPendingOutputEOS = drainMode == DRAIN_COMPONENT_WITH_EOS;
}
// Put work to mPendingWorks.
mPendingWorks.emplace_back(std::move(work));
if (isEmptyCSDWork) {
// Directly report the empty CSD work as finished.
reportWorkIfFinished(bitstreamId);
}
if (!mQueue.empty()) {
mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onDequeueWork,
::base::Unretained(this)));
}
}
void C2VDAComponent::onInputBufferDone(int32_t bitstreamId) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onInputBufferDone: bitstream id=%d", bitstreamId);
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
C2Work* work = getPendingWorkByBitstreamId(bitstreamId);
if (!work) {
reportError(C2_CORRUPTED);
return;
}
// When the work is done, the input buffer shall be reset by component.
work->input.buffers.front().reset();
reportWorkIfFinished(bitstreamId);
}
void C2VDAComponent::onOutputBufferReturned(std::shared_ptr<C2GraphicBlock> block,
uint32_t poolId) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onOutputBufferReturned: pool id=%u", poolId);
if (mComponentState == ComponentState::UNINITIALIZED) {
// Output buffer is returned from client after component is stopped. Just let the buffer be
// released.
return;
}
if (block->width() != static_cast<uint32_t>(mOutputFormat.mCodedSize.width()) ||
block->height() != static_cast<uint32_t>(mOutputFormat.mCodedSize.height())) {
// Output buffer is returned after we changed output resolution. Just let the buffer be
// released.
ALOGV("Discard obsolete graphic block: pool id=%u", poolId);
return;
}
GraphicBlockInfo* info = getGraphicBlockByPoolId(poolId);
if (!info) {
reportError(C2_CORRUPTED);
return;
}
CHECK_EQ(info->mState, GraphicBlockInfo::State::OWNED_BY_CLIENT);
info->mGraphicBlock = std::move(block);
info->mState = GraphicBlockInfo::State::OWNED_BY_COMPONENT;
if (mPendingOutputFormat) {
tryChangeOutputFormat();
} else {
// Do not pass the ownership to accelerator if this buffer will still be reused under
// |mPendingBuffersToWork|.
auto existingFrame = std::find_if(
mPendingBuffersToWork.begin(), mPendingBuffersToWork.end(),
[id = info->mBlockId](const OutputBufferInfo& o) { return o.mBlockId == id; });
bool ownByAccelerator = existingFrame == mPendingBuffersToWork.end();
sendOutputBufferToAccelerator(info, ownByAccelerator);
sendOutputBufferToWorkIfAny(false /* dropIfUnavailable */);
}
}
void C2VDAComponent::onOutputBufferDone(int32_t pictureBufferId, int32_t bitstreamId) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onOutputBufferDone: picture id=%d, bitstream id=%d", pictureBufferId, bitstreamId);
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
GraphicBlockInfo* info = getGraphicBlockById(pictureBufferId);
if (!info) {
reportError(C2_CORRUPTED);
return;
}
if (info->mState == GraphicBlockInfo::State::OWNED_BY_ACCELERATOR) {
info->mState = GraphicBlockInfo::State::OWNED_BY_COMPONENT;
}
mPendingBuffersToWork.push_back({bitstreamId, pictureBufferId});
sendOutputBufferToWorkIfAny(false /* dropIfUnavailable */);
}
void C2VDAComponent::sendOutputBufferToWorkIfAny(bool dropIfUnavailable) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
while (!mPendingBuffersToWork.empty()) {
auto nextBuffer = mPendingBuffersToWork.front();
GraphicBlockInfo* info = getGraphicBlockById(nextBuffer.mBlockId);
CHECK_NE(info->mState, GraphicBlockInfo::State::OWNED_BY_ACCELERATOR);
C2Work* work = getPendingWorkByBitstreamId(nextBuffer.mBitstreamId);
if (!work) {
reportError(C2_CORRUPTED);
return;
}
if (info->mState == GraphicBlockInfo::State::OWNED_BY_CLIENT) {
// This buffer is the existing frame and still owned by client.
if (!dropIfUnavailable &&
std::find(mUndequeuedBlockIds.begin(), mUndequeuedBlockIds.end(),
nextBuffer.mBlockId) == mUndequeuedBlockIds.end()) {
ALOGV("Still waiting for existing frame returned from client...");
return;
}
ALOGV("Drop this frame...");
sendOutputBufferToAccelerator(info, false /* ownByAccelerator */);
work->worklets.front()->output.flags = C2FrameData::FLAG_DROP_FRAME;
} else {
// This buffer is ready to push into the corresponding work.
// Output buffer will be passed to client soon along with mListener->onWorkDone_nb().
info->mState = GraphicBlockInfo::State::OWNED_BY_CLIENT;
mBuffersInClient++;
updateUndequeuedBlockIds(info->mBlockId);
// Attach output buffer to the work corresponded to bitstreamId.
C2ConstGraphicBlock constBlock = info->mGraphicBlock->share(
C2Rect(mOutputFormat.mVisibleRect.width(),
mOutputFormat.mVisibleRect.height()),
C2Fence());
MarkBlockPoolDataAsShared(constBlock);
std::shared_ptr<C2Buffer> buffer = C2Buffer::CreateGraphicBuffer(std::move(constBlock));
if (mPendingColorAspectsChange &&
work->input.ordinal.frameIndex.peeku() >= mPendingColorAspectsChangeFrameIndex) {
updateColorAspects();
mPendingColorAspectsChange = false;
}
if (mCurrentColorAspects) {
buffer->setInfo(mCurrentColorAspects);
}
work->worklets.front()->output.buffers.emplace_back(std::move(buffer));
info->mGraphicBlock.reset();
}
reportWorkIfFinished(nextBuffer.mBitstreamId);
mPendingBuffersToWork.pop_front();
}
}
void C2VDAComponent::updateUndequeuedBlockIds(int32_t blockId) {
// The size of |mUndequedBlockIds| will always be the minimum buffer count for display.
mUndequeuedBlockIds.push_back(blockId);
mUndequeuedBlockIds.pop_front();
}
void C2VDAComponent::onDrain(uint32_t drainMode) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onDrain: mode = %u", drainMode);
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
if (!mQueue.empty()) {
// Mark last queued work as "drain-till-here" by setting drainMode. Do not change drainMode
// if last work already has one.
if (mQueue.back().mDrainMode == NO_DRAIN) {
mQueue.back().mDrainMode = drainMode;
}
} else if (!mPendingWorks.empty()) {
// Neglect drain request if component is not in STARTED mode. Otherwise, enters DRAINING
// mode and signal VDA flush immediately.
if (mComponentState == ComponentState::STARTED) {
mVDAAdaptor->flush();
mComponentState = ComponentState::DRAINING;
mPendingOutputEOS = drainMode == DRAIN_COMPONENT_WITH_EOS;
} else {
ALOGV("Neglect drain. Component in state: %d", mComponentState);
}
} else {
// Do nothing.
ALOGV("No buffers in VDA, drain takes no effect.");
}
}
void C2VDAComponent::onDrainDone() {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onDrainDone");
if (mComponentState == ComponentState::DRAINING) {
mComponentState = ComponentState::STARTED;
} else if (mComponentState == ComponentState::STOPPING) {
// The client signals stop right before VDA notifies drain done. Let stop process goes.
return;
} else if (mComponentState != ComponentState::FLUSHING) {
// It is reasonable to get onDrainDone in FLUSHING, which means flush is already signaled
// and component should still expect onFlushDone callback from VDA.
ALOGE("Unexpected state while onDrainDone(). State=%d", mComponentState);
reportError(C2_BAD_STATE);
return;
}
// Drop all pending existing frames and return all finished works before drain done.
sendOutputBufferToWorkIfAny(true /* dropIfUnavailable */);
CHECK(mPendingBuffersToWork.empty());
if (mPendingOutputEOS) {
// Return EOS work.
reportEOSWork();
}
// mPendingWorks must be empty after draining is finished.
CHECK(mPendingWorks.empty());
// Work dequeueing was stopped while component draining. Restart it.
mTaskRunner->PostTask(FROM_HERE,
::base::Bind(&C2VDAComponent::onDequeueWork, ::base::Unretained(this)));
}
void C2VDAComponent::onFlush() {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onFlush");
if (mComponentState == ComponentState::FLUSHING ||
mComponentState == ComponentState::STOPPING) {
return; // Ignore other flush request when component is flushing or stopping.
}
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
mVDAAdaptor->reset();
// Pop all works in mQueue and put into mAbandonedWorks.
while (!mQueue.empty()) {
mAbandonedWorks.emplace_back(std::move(mQueue.front().mWork));
mQueue.pop();
}
mComponentState = ComponentState::FLUSHING;
}
void C2VDAComponent::onStop(::base::WaitableEvent* done) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onStop");
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
// Do not request VDA reset again before the previous one is done. If reset is already sent by
// onFlush(), just regard the following NotifyResetDone callback as for stopping.
if (mComponentState != ComponentState::FLUSHING) {
mVDAAdaptor->reset();
}
// Pop all works in mQueue and put into mAbandonedWorks.
while (!mQueue.empty()) {
mAbandonedWorks.emplace_back(std::move(mQueue.front().mWork));
mQueue.pop();
}
mStopDoneEvent = done; // restore done event which shoud be signaled in onStopDone().
mComponentState = ComponentState::STOPPING;
}
void C2VDAComponent::onResetDone() {
DCHECK(mTaskRunner->BelongsToCurrentThread());
if (mComponentState == ComponentState::ERROR) {
return;
}
if (mComponentState == ComponentState::FLUSHING) {
onFlushDone();
} else if (mComponentState == ComponentState::STOPPING) {
onStopDone();
} else {
reportError(C2_CORRUPTED);
}
}
void C2VDAComponent::onFlushDone() {
ALOGV("onFlushDone");
reportAbandonedWorks();
mPendingBuffersToWork.clear();
mComponentState = ComponentState::STARTED;
// Work dequeueing was stopped while component flushing. Restart it.
mTaskRunner->PostTask(FROM_HERE,
::base::Bind(&C2VDAComponent::onDequeueWork, ::base::Unretained(this)));
}
void C2VDAComponent::onStopDone() {
ALOGV("onStopDone");
CHECK(mStopDoneEvent);
// TODO(johnylin): At this moment, there may be C2Buffer still owned by client, do we need to
// do something for them?
reportAbandonedWorks();
mPendingOutputFormat.reset();
mPendingBuffersToWork.clear();
if (mVDAAdaptor.get()) {
mVDAAdaptor->destroy();
mVDAAdaptor.reset(nullptr);
}
stopDequeueThread();
mGraphicBlocks.clear();
mStopDoneEvent->Signal();
mStopDoneEvent = nullptr;
mComponentState = ComponentState::UNINITIALIZED;
}
c2_status_t C2VDAComponent::setListener_vb(const std::shared_ptr<C2Component::Listener>& listener,
c2_blocking_t mayBlock) {
UNUSED(mayBlock);
// TODO(johnylin): API says this method must be supported in all states, however I'm quite not
// sure what is the use case.
if (mState.load() != State::LOADED) {
return C2_BAD_STATE;
}
mListener = listener;
return C2_OK;
}
void C2VDAComponent::sendInputBufferToAccelerator(const C2ConstLinearBlock& input,
int32_t bitstreamId) {
ALOGV("sendInputBufferToAccelerator");
int dupFd = dup(input.handle()->data[0]);
if (dupFd < 0) {
ALOGE("Failed to dup(%d) input buffer (bitstreamId=%d), errno=%d", input.handle()->data[0],
bitstreamId, errno);
reportError(C2_CORRUPTED);
return;
}
ALOGV("Decode bitstream ID: %d, offset: %u size: %u", bitstreamId, input.offset(),
input.size());
mVDAAdaptor->decode(bitstreamId, dupFd, input.offset(), input.size());
}
std::deque<std::unique_ptr<C2Work>>::iterator C2VDAComponent::findPendingWorkByBitstreamId(
int32_t bitstreamId) {
return std::find_if(mPendingWorks.begin(), mPendingWorks.end(),
[bitstreamId](const std::unique_ptr<C2Work>& w) {
return frameIndexToBitstreamId(w->input.ordinal.frameIndex) ==
bitstreamId;
});
}
C2Work* C2VDAComponent::getPendingWorkByBitstreamId(int32_t bitstreamId) {
auto workIter = findPendingWorkByBitstreamId(bitstreamId);
if (workIter == mPendingWorks.end()) {
ALOGE("Can't find pending work by bitstream ID: %d", bitstreamId);
return nullptr;
}
return workIter->get();
}
C2VDAComponent::GraphicBlockInfo* C2VDAComponent::getGraphicBlockById(int32_t blockId) {
if (blockId < 0 || blockId >= static_cast<int32_t>(mGraphicBlocks.size())) {
ALOGE("getGraphicBlockById failed: id=%d", blockId);
return nullptr;
}
return &mGraphicBlocks[blockId];
}
C2VDAComponent::GraphicBlockInfo* C2VDAComponent::getGraphicBlockByPoolId(uint32_t poolId) {
auto blockIter = std::find_if(mGraphicBlocks.begin(), mGraphicBlocks.end(),
[poolId](const GraphicBlockInfo& gb) {
return gb.mPoolId == poolId;
});
if (blockIter == mGraphicBlocks.end()) {
ALOGE("getGraphicBlockByPoolId failed: poolId=%u", poolId);
return nullptr;
}
return &(*blockIter);
}
void C2VDAComponent::onOutputFormatChanged(std::unique_ptr<VideoFormat> format) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onOutputFormatChanged");
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
ALOGV("New output format(pixel_format=0x%x, min_num_buffers=%u, coded_size=%s, crop_rect=%s)",
static_cast<uint32_t>(format->mPixelFormat), format->mMinNumBuffers,
format->mCodedSize.ToString().c_str(), format->mVisibleRect.ToString().c_str());
for (auto& info : mGraphicBlocks) {
if (info.mState == GraphicBlockInfo::State::OWNED_BY_ACCELERATOR)
info.mState = GraphicBlockInfo::State::OWNED_BY_COMPONENT;
}
CHECK(!mPendingOutputFormat);
mPendingOutputFormat = std::move(format);
tryChangeOutputFormat();
}
void C2VDAComponent::tryChangeOutputFormat() {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("tryChangeOutputFormat");
CHECK(mPendingOutputFormat);
// At this point, all output buffers should not be owned by accelerator. The component is not
// able to know when a client will release all owned output buffers by now. But it is ok to
// leave them to client since componenet won't own those buffers anymore.
// TODO(johnylin): we may also set a parameter for component to keep dequeueing buffers and
// change format only after the component owns most buffers. This may prevent
// too many buffers are still on client's hand while component starts to
// allocate more buffers. However, it leads latency on output format change.
for (const auto& info : mGraphicBlocks) {
CHECK(info.mState != GraphicBlockInfo::State::OWNED_BY_ACCELERATOR);
}
// Drop all pending existing frames and return all finished works before changing output format.
sendOutputBufferToWorkIfAny(true /* dropIfUnavailable */);
CHECK(mPendingBuffersToWork.empty());
CHECK_EQ(mPendingOutputFormat->mPixelFormat, HalPixelFormat::YCbCr_420_888);
mOutputFormat.mPixelFormat = mPendingOutputFormat->mPixelFormat;
mOutputFormat.mMinNumBuffers = mPendingOutputFormat->mMinNumBuffers;
mOutputFormat.mCodedSize = mPendingOutputFormat->mCodedSize;
setOutputFormatCrop(mPendingOutputFormat->mVisibleRect);
c2_status_t err = allocateBuffersFromBlockAllocator(
mPendingOutputFormat->mCodedSize,
static_cast<uint32_t>(mPendingOutputFormat->mPixelFormat));
if (err != C2_OK) {
reportError(err);
return;
}
for (auto& info : mGraphicBlocks) {
sendOutputBufferToAccelerator(&info, true /* ownByAccelerator */);
}
mPendingOutputFormat.reset();
}
c2_status_t C2VDAComponent::allocateBuffersFromBlockAllocator(const media::Size& size,
uint32_t pixelFormat) {
ALOGV("allocateBuffersFromBlockAllocator(%s, 0x%x)", size.ToString().c_str(), pixelFormat);
stopDequeueThread();
size_t bufferCount = mOutputFormat.mMinNumBuffers + kDpbOutputBufferExtraCount;
// Allocate the output buffers.
mVDAAdaptor->assignPictureBuffers(bufferCount);
// Get block pool ID configured from the client.
std::shared_ptr<C2BlockPool> blockPool;
auto poolId = mIntfImpl->getBlockPoolId();
ALOGI("Using C2BlockPool ID = %" PRIu64 " for allocating output buffers", poolId);
auto err = GetCodec2BlockPool(poolId, shared_from_this(), &blockPool);
if (err != C2_OK) {
ALOGE("Graphic block allocator is invalid");
reportError(err);
return err;
}
mGraphicBlocks.clear();